def validate_object(obj, field_validators=None, non_field_validators=None, schema=None, context=None): """ Takes a mapping and applies a mapping of validator functions to it collecting and reraising any validation errors that occur. """ if schema is None: schema = {} if context is None: context = {} if field_validators is None: field_validators = ValidationDict() if non_field_validators is None: non_field_validators = ValidationList() from flex.validation.schema import ( construct_schema_validators, ) schema_validators = construct_schema_validators(schema, context) if '$ref' in schema_validators and hasattr(schema_validators['$ref'], 'validators'): ref_ = field_validators.pop('$ref') for k, v in ref_.validators.items(): if k not in schema_validators: schema_validators.add_validator(k, v) if 'discriminator' in schema: add_polymorphism_requirements(obj, schema, context, schema_validators) schema_validators.update(field_validators) schema_validators.validate_object(obj, context=context) non_field_validators.validate_object(obj, context=context) return obj
def validate_object(obj, field_validators=None, non_field_validators=None, schema=None, context=None): """ Takes a mapping and applies a mapping of validator functions to it collecting and reraising any validation errors that occur. """ if schema is None: schema = {} if context is None: context = {} if field_validators is None: field_validators = ValidationDict() if non_field_validators is None: non_field_validators = ValidationList() from flex.validation.schema import ( construct_schema_validators, ) schema_validators = construct_schema_validators(schema, context) if '$ref' in schema_validators and hasattr(schema_validators['$ref'], 'validators'): ref_ = field_validators.pop('$ref') for k, v in ref_.validators.items(): if k not in schema_validators: schema_validators.add_validator(k, v) schema_validators.update(field_validators) schema_validators.validate_object(obj, context=context) non_field_validators.validate_object(obj, context=context) return obj
def generate_response_body_validator(schema, context, inner=False): validators = construct_schema_validators(schema, context=context) return chain_reduce_partial( operator.attrgetter('data'), functools.partial( validate_object, validators=validators, inner=True, ), )
def construct_parameter_validators(parameter, context): """ Constructs a dictionary of validator functions for the provided parameter definition. """ validators = {} if 'schema' in parameter: validators.update(construct_schema_validators(parameter['schema'], context=context)) for key in parameter: if key in validator_mapping: validators[key] = validator_mapping[key](context=context, **parameter) return validators
def add_polymorphism_requirements(obj, schema, context, schema_validators): try: object_type = obj[schema['discriminator']] except KeyError: raise ValidationError("No discriminator found on instance [{0}].".format(obj)) try: object_schema = context['definitions'][object_type] except KeyError: raise ValidationError("No definition for class [{0}]".format(object_type)) from flex.validation.schema import ( construct_schema_validators, ) subtype_validators = construct_schema_validators(object_schema, context) schema_validators.update(subtype_validators) return schema_validators
def construct_parameter_validators(parameter, context): """ Constructs a dictionary of validator functions for the provided parameter definition. """ validators = ValidationDict() for key in parameter: if key in validator_mapping: validators.add_validator( key, validator_mapping[key](context=context, **parameter), ) if 'schema' in parameter: schema_validators = construct_schema_validators(parameter['schema'], context=context) for key, value in schema_validators.items(): validators.setdefault(key, value) return validators
def validate_allof_anyof(value, sub_schemas, context, method, **kwargs): from flex.validation.schema import ( construct_schema_validators, ) messages = [] success = [] for schema in sub_schemas: schema_validators = construct_schema_validators(schema, context) try: schema_validators.validate_object(value, context=context) except ValidationError as err: messages.append(err.messages) success.append(False) else: success.append(True) if not method(success): raise ValidationError(messages) return value
def construct_parameter_validators(parameter, context): """ Constructs a dictionary of validator functions for the provided parameter definition. """ validators = ValidationDict() if '$ref' in parameter: validators.add_validator( '$ref', ParameterReferenceValidator(parameter['$ref'], context), ) for key in parameter: if key in validator_mapping: validators.add_validator( key, validator_mapping[key](context=context, **parameter), ) if 'schema' in parameter: schema_validators = construct_schema_validators(parameter['schema'], context=context) for key, value in schema_validators.items(): validators.setdefault(key, value) return validators
def validate_allof_anyof(value, sub_schemas, context, method, **kwargs): from flex.validation.schema import ( construct_schema_validators, ) messages = [] success = [] for schema in sub_schemas: schema_validators = construct_schema_validators(schema, context) try: schema_validators.validate_object(value, context=context) except ValidationError as err: messages.append(err.messages) success.append(False) else: success.append(True) if not method(success): raise ValidationError(messages) return value
from flex.validation.schema import ( construct_schema_validators, ) from flex.decorators import ( pull_keys_from_obj, suffix_reserved_words, skip_if_any_kwargs_empty, ) @pull_keys_from_obj('type', 'minProperties') @suffix_reserved_words @skip_if_any_kwargs_empty('type_', 'minProperties') def validate_type_for_min_properties(type_, minProperties, **kwargs): types = pluralize(type_) if not set(types).intersection((OBJECT,)): raise ValidationError( MESSAGES['type']['invalid_type_for_min_properties'], ) min_properties_schema = { 'type': INTEGER, 'minimum': 0, } min_properties_validators = construct_schema_validators(min_properties_schema, {}) min_properties_validator = generate_object_validator( field_validators=min_properties_validators, )
from flex.constants import ( STRING, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) title_schema = { 'type': STRING, } title_validators = construct_schema_validators(title_schema, {}) title_validator = generate_object_validator( field_validators=title_validators, )
) @pull_keys_from_obj('minItems', 'maxItems') def validate_max_items_greater_than_or_equal_to_min_items( minItems, maxItems, **kwargs): if minItems is EMPTY or maxItems is EMPTY: return if not maxItems >= minItems: raise ValidationError( MESSAGES['max_items']['must_be_greater_than_min_items']) @pull_keys_from_obj('type', 'maxItems') @suffix_reserved_words @skip_if_any_kwargs_empty('type_', 'maxItems') def validate_type_for_max_items(type_, maxItems, **kwargs): types = pluralize(type_) if not set(types).intersection((ARRAY, )): raise ValidationError(MESSAGES['type']['invalid_type_for_max_items'], ) max_items_schema = { 'type': INTEGER, } max_items_validators = construct_schema_validators(max_items_schema, {}) max_items_validator = generate_object_validator( field_validators=max_items_validators, )
construct_schema_validators, ) single_type_schema = { 'type': STRING, 'enum': [ NULL, BOOLEAN, INTEGER, NUMBER, STRING, ARRAY, ], } single_type_validators = construct_schema_validators(single_type_schema, {}) single_type_validator = generate_object_validator( field_validators=single_type_validators, ) @suffix_reserved_words @skip_if_not_of_type(ARRAY, STRING) def validate_types(type_, **kwargs): types = pluralize(type_) with ErrorList() as errors: for value in types: try: single_type_validator(value)
from flex.exceptions import ValidationError from flex.error_messages import MESSAGES from flex.constants import BOOLEAN, ARRAY from flex.utils import pluralize from flex.validation.common import generate_object_validator from flex.validation.schema import construct_schema_validators from flex.decorators import pull_keys_from_obj, suffix_reserved_words, skip_if_any_kwargs_empty @pull_keys_from_obj("type", "uniqueItems") @suffix_reserved_words @skip_if_any_kwargs_empty("type_", "uniqueItems") def validate_type_for_unique_items(type_, uniqueItems, **kwargs): types = pluralize(type_) if not uniqueItems: return if not set(types).intersection((ARRAY,)): raise ValidationError(MESSAGES["type"]["invalid_type_for_unique_items"]) unique_items_schema = {"type": BOOLEAN} unique_items_validators = construct_schema_validators(unique_items_schema, {}) unique_items_validator = generate_object_validator(field_validators=unique_items_validators)
from flex.constants import ( BOOLEAN, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) required_schema = { 'type': BOOLEAN, } required_validators = construct_schema_validators(required_schema, {}) required_validator = generate_object_validator( field_validators=required_validators, )
from flex.decorators import ( pull_keys_from_obj, suffix_reserved_words, skip_if_any_kwargs_empty, ) @pull_keys_from_obj('type', 'uniqueItems') @suffix_reserved_words @skip_if_any_kwargs_empty('type_', 'uniqueItems') def validate_type_for_unique_items(type_, uniqueItems, **kwargs): types = pluralize(type_) if not uniqueItems: return if not set(types).intersection((ARRAY,)): raise ValidationError( MESSAGES['type']['invalid_type_for_unique_items'], ) unique_items_schema = { 'type': BOOLEAN, } unique_items_validators = construct_schema_validators(unique_items_schema, {}) unique_items_validator = generate_object_validator( field_validators=unique_items_validators, )
from flex.constants import ( STRING, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) format_schema = { 'type': STRING, } format_validators = construct_schema_validators(format_schema, {}) format_validator = generate_object_validator( field_validators=format_validators, )
from flex.constants import ( ARRAY, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) enum_schema = { 'type': ARRAY, 'minItems': 1, } enum_validators = construct_schema_validators(enum_schema, {}) enum_validator = generate_object_validator(field_validators=enum_validators, )
) single_type_schema = { 'type': STRING, 'enum': [ NULL, BOOLEAN, INTEGER, NUMBER, STRING, ARRAY, OBJECT, ], } single_type_validators = construct_schema_validators(single_type_schema, {}) single_type_validator = generate_object_validator( field_validators=single_type_validators, ) @suffix_reserved_words @skip_if_not_of_type(ARRAY, STRING) def validate_types(type_, **kwargs): types = pluralize(type_) with ErrorList() as errors: for value in types: try: single_type_validator(value)
from flex.constants import ( STRING, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) format_schema = { 'type': STRING, } format_validators = construct_schema_validators(format_schema, {}) format_validator = generate_object_validator( field_validators=format_validators, )
from flex.constants import ( BOOLEAN, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) read_only_schema = { 'type': BOOLEAN, } read_only_validators = construct_schema_validators(read_only_schema, {}) read_only_validator = generate_object_validator( field_validators=read_only_validators, )
) from flex.validation.schema import ( construct_schema_validators, ) from flex.decorators import ( skip_if_empty, skip_if_not_of_type, ) @skip_if_empty @skip_if_not_of_type(STRING) def regex_validator(value, **kwargs): try: re.compile(value) except re.error: raise ValidationError( MESSAGES['pattern']['invalid_regex'].format(value) ) pattern_schema = { 'type': STRING, } pattern_validators = construct_schema_validators(pattern_schema, {}) pattern_validators.add_validator('regex', regex_validator) pattern_validator = generate_object_validator( field_validators=pattern_validators, )
from flex.error_messages import MESSAGES from flex.constants import INTEGER, EMPTY, ARRAY from flex.utils import pluralize from flex.validation.common import generate_object_validator from flex.validation.schema import construct_schema_validators from flex.decorators import pull_keys_from_obj, suffix_reserved_words, skip_if_any_kwargs_empty @pull_keys_from_obj("minItems", "maxItems") def validate_max_items_greater_than_or_equal_to_min_items(minItems, maxItems, **kwargs): if minItems is EMPTY or maxItems is EMPTY: return if not maxItems >= minItems: raise ValidationError(MESSAGES["max_items"]["must_be_greater_than_min_items"]) @pull_keys_from_obj("type", "maxItems") @suffix_reserved_words @skip_if_any_kwargs_empty("type_", "maxItems") def validate_type_for_max_items(type_, maxItems, **kwargs): types = pluralize(type_) if not set(types).intersection((ARRAY,)): raise ValidationError(MESSAGES["type"]["invalid_type_for_max_items"]) max_items_schema = {"type": INTEGER} max_items_validators = construct_schema_validators(max_items_schema, {}) max_items_validator = generate_object_validator(field_validators=max_items_validators)
from flex.constants import ( ARRAY, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) enum_schema = { 'type': ARRAY, 'minItems': 1, } enum_validators = construct_schema_validators(enum_schema, {}) enum_validator = generate_object_validator( field_validators=enum_validators, )
def save_object(self, obj, **kwargs): validators = construct_schema_validators(obj, self.context) self.object = functools.partial(validate_object, validators=validators)
from flex.constants import ( BOOLEAN, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) read_only_schema = { 'type': BOOLEAN, } read_only_validators = construct_schema_validators(read_only_schema, {}) read_only_validator = generate_object_validator( field_validators=read_only_validators, )
from flex.constants import ( ARRAY, STRING, ) from flex.validation.common import ( generate_object_validator, ) from flex.validation.schema import ( construct_schema_validators, ) required_schema = { 'type': ARRAY, 'items': { 'type': STRING, }, 'uniqueItems': True, } required_validators = construct_schema_validators(required_schema, {}) required_validator = generate_object_validator( field_validators=required_validators, )