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 own_additional_properties(validator, aP, instance, schema) -> Iterator: # type: ignore """Additional properties validator.""" for _ in additionalProperties(validator, aP, instance, schema): raise ExtraPropertiesError( list(find_additional_properties(instance, schema))) return iter(())
def scrub_index_data(index_data: dict, bundle_id: str) -> list: cache = S3UrlCache() def request_json(url): return json.loads(cache.resolve(url).decode("utf-8")) resolver = validators.RefResolver(referrer='', base_uri='', handlers={ 'http': request_json, 'https': request_json }) extra_fields = [] extra_documents = [] for document in index_data.keys(): for doc_list_ind, document_content in enumerate(index_data[document]): schema_info = SchemaInfo.from_json(document_content) if schema_info is not None: try: schema = request_json(schema_info.url) except Exception as ex: extra_documents.append(document) logger.warning( f"Unable to retrieve JSON schema information from {document} in bundle {bundle_id} " f"because retrieving {schema_info.url} caused exception: {ex}." ) else: for error in DSS_Draft4Validator( schema, resolver=resolver).iter_errors(document_content): if error.validator == 'additionalProperties': path = [document, doc_list_ind, *error.path] # Example error message: "Additional properties are not allowed ('extra_lst', 'extra_top' # were unexpected)" or "'extra', does not match any of the regexes: '^characteristics_.*$'" fields_to_remove = (path, [ field for field in _utils.find_additional_properties( error.instance, error.schema) ]) extra_fields.append(fields_to_remove) else: logger.warning( f"Unable to retrieve JSON schema information from {document} in bundle {bundle_id}." ) extra_documents.append(document) if extra_documents: extra_fields.append(([], extra_documents)) removed_fields = [] for path, fields in extra_fields: remove_json_fields(index_data, path, fields) removed_fields.extend( ['.'.join((*[str(p) for p in path], field)) for field in fields]) if removed_fields: logger.info( f"In {bundle_id}, unexpected additional fields have been removed from the data" f" to be indexed. Removed {removed_fields}.") return removed_fields
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 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 handle_error_for_schema_with_id(error, path): schema_id = error.schema['id'] if is_service_dict_schema( schema_id) and error.validator == 'additionalProperties': properties = _utils.find_additional_properties(error.instance, error.schema) return "Invalid service name '{}' - only {} characters are allowed".format( # The service_name is the key to the json object properties.next(), VALID_NAME_CHARS) if error.validator == 'additionalProperties': if schema_id == '#/definitions/service': invalid_config_key = parse_key_from_error_msg(error) return get_unsupported_config_msg(path, invalid_config_key) if not error.path: return '{}\n{}'.format(error.message, VERSION_EXPLANATION)
def _additional_properties(validator, aP, instance, schema): """Validate 'additionalProperties' properties.""" from jsonschema import _utils if not validator.is_type(instance, "object"): # pragma: no cover return extras = set(_utils.find_additional_properties(instance, schema)) if validator.is_type(aP, "object"): # We hardly use this below for extra in extras: # pragma: no cover for error in validator.descend(instance[extra], aP, path=extra): yield error elif not aP and extras: for extra in extras: error = jsonschema.ValidationError("Unrecognized property") error.path.append(extra) yield error
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))
def flex_additionalProperties(schema, err): extras = find_additional_properties(err.instance, err.schema) for extra in extras: schema['properties'][extra] = json2schema(err.instance[extra], extra, err.path)