Pass schema's context to validation functions

I am thinking about a way to pass context to validation function.

Currently validation function expect exactly one argument, value of a field. Maybe Field._validate method can check with inspect.getargspec and if function expect two arguments, send schema’s context as second argument?

I know that context is available in validation methods declared with @validates decorator, but I want to reuse validation function in different schemas with different fields.

[deckar01]

@kevgliss You can use the existing @validate_schema decorator to validate against the schema context. The field_names parameter of the ValidationError exception allows you to specify which field(s) the error belongs to.

class IPSchema(Schema):
    cidr = fields.String()

   @validate_schema
   def valid_network(self, data):
        cidr = data['cidr']
        if cidr not in self.context.get('whitelisted_networks', []):
            raise ValidationError('Network {0} is not allowed'.format(cidr), ['cidr'])

[deckar01]

I want to reuse validation function in different schemas with different fields.

I didn’t fully digest this requirement the first time around.

Currently you would have to:

def validate_foo(foo, field_name, context):
    if foo not in context['bar']:
        raise ValidationError('Foo must be in bar', [field_name])

class ItemSchema(Schema):
    quantity = fields.Integer()

    @validates_schema
    def validate_quantity(self, data):
        validate_foo(data['quantity'], 'quantity', self.context)

class AnotherSchema(Schema):
    quantity = fields.Integer()

    @validates_schema
    def validate_quantity(self, data):
        validate_foo(data['quantity'], 'quantity', self.context)

but it would be a lot more convenient if you had access to the context in a field validator:

@pass_schema_context
def validate_foo(foo, context):
    if foo not in context['bar']:
        raise ValidationError('Foo must be in bar')

class ItemSchema(Schema):
    quantity = fields.Integer(validate=validate_foo)

class AnotherSchema(Schema):
    quantity = fields.Integer(validate=validate_foo)

So Field._validate() would need to be able to efficiently identify when a validator has been wrapped in @pass_schema_context decorator and provide the schema context as an additional argument.

I’m not sure it makes sense to use a decorator outside of the schema body in order to identify that a field-level validator expects schema-level data. All the other decorators are used to register a processor with a specific schema class.