def additionalProperties(validator, aP, instance, schema): if not validator.is_type(instance, "object"): return extras = set(_utils.find_additional_properties(instance, schema)) if validator.is_type(aP, "object"): for extra in extras: for error in validator.descend(instance[extra], aP, path=extra): yield error elif not aP and extras: if "patternProperties" in schema: patterns = sorted(schema["patternProperties"]) if len(extras) == 1: verb = "does" else: verb = "do" error = "%s %s not match any of the regexes: %s" % ( ", ".join(map(repr, sorted(extras))), verb, ", ".join(map(repr, patterns)), ) yield ValidationError(error) else: error = "Additional properties are not allowed (%s %s unexpected)" yield ValidationError(error % _utils.extras_msg(extras))
def additionalItems(validator, aI, instance, schema): if not validator.is_type(instance, "array") or validator.is_type(schema.get("items", {}), "object"): return if validator.is_type(aI, "object"): for index, item in enumerate(instance[len(schema.get("items", [])) :]): for error in validator.descend(item, aI, path=index): yield error elif not aI and len(instance) > len(schema.get("items", [])): error = "Additional items are not allowed (%s %s unexpected)" yield ValidationError(error % _utils.extras_msg(instance[len(schema.get("items", [])) :]))
def additionalProperties(validator, aP, instance, schema): if not validator.is_type(instance, "object"): return extras = set(_utils.find_additional_properties(instance, schema)) if validator.is_type(aP, "object"): for extra in extras: for error in validator.descend(instance[extra], aP, path=extra): yield error elif not aP and extras: error = "Additional properties are not allowed (%s %s unexpected)" yield ValidationError(error % _utils.extras_msg(extras))
def additionalItems(validator, aI, instance, schema): if (not validator.is_type(instance, "array") or validator.is_type(schema.get("items", {}), "object")): return if validator.is_type(aI, "object"): for index, item in enumerate(instance[len(schema.get("items", [])):]): for error in validator.descend(item, aI, path=index): yield error elif not aI and len(instance) > len(schema.get("items", [])): error = "Additional items are not allowed (%s %s unexpected)" yield ValidationError( error % _utils.extras_msg(instance[len(schema.get("items", [])):]))
def unevaluatedItems(validator, unevaluatedItems, instance, schema): evaluated_item_indexes = find_evaluated_item_indexes_by_schema( validator, instance, schema, ) unevaluated_items = [ item for index, item in enumerate(instance) if index not in evaluated_item_indexes ] if unevaluated_items: error = "Unevaluated items are not allowed (%s %s unexpected)" yield ValidationError(error % extras_msg(unevaluated_items))
def strictProperties_draft5(validator, sP, instance, schema): if not validator.is_type(instance, "object"): return extras = set(_utils.find_additional_properties(instance, schema, strict=True)) missing = _utils.property_missing(instance, schema) if sP and (extras or (missing is not None)): if extras: error = ("Additional properties are strictly not allowed (%s %s unexpected)" % _utils.extras_msg(extras,)) else: error = "Missing strictly required property (%s)" % (missing,) yield ValidationError(error)
def additionalItems(validator, aI, instance, schema): if ( not validator.is_type(instance, "array") or validator.is_type(schema.get("items", {}), "object") ): return len_items = len(schema.get("items", [])) if validator.is_type(aI, "object"): for index, item in enumerate(instance[len_items:], start=len_items): for error in validator.descend(item, aI, path=index): yield error elif not aI and len(instance) > len(schema.get("items", [])): error = "tag-msg_dataCheck_key_invalid.Additional items are not allowed (tagPara :%s %s, unexpected)" yield ValidationError( error % _utils.extras_msg(instance[len(schema.get("items", [])):]) )
def unevaluatedProperties(validator, unevaluatedProperties, instance, schema): evaluated_property_keys = find_evaluated_property_keys_by_schema( validator, instance, schema, ) unevaluated_property_keys = [] for property in instance: if property not in evaluated_property_keys: for _ in validator.descend( instance[property], unevaluatedProperties, path=property, schema_path=property, ): unevaluated_property_keys.append(property) if unevaluated_property_keys: error = "Unevaluated properties are not allowed (%s %s unexpected)" yield ValidationError(error % extras_msg(unevaluated_property_keys))
def additionalProperties(validator, aP, instance, schema): if not validator.is_type(instance, "object"): return extras = set(find_additional_properties(instance, schema)) if validator.is_type(aP, "object"): for extra in extras: yield from validator.descend(instance[extra], aP, path=extra) elif not aP and extras: if "patternProperties" in schema: if len(extras) == 1: verb = "does" else: verb = "do" joined = ", ".join(repr(each) for each in sorted(extras)) patterns = ", ".join( repr(each) for each in sorted(schema["patternProperties"])) error = f"{joined} {verb} not match any of the regexes: {patterns}" yield ValidationError(error) else: error = "Additional properties are not allowed (%s %s unexpected)" yield ValidationError(error % extras_msg(extras))