def is_valid(self): handlers = {'https': self.session_request_json, 'http': self.session_request_json} resolver = RefResolver.from_schema(self.schema.raw_schema, handlers=handlers) try: validate(self.data, self.schema.raw_schema, resolver=resolver) except (SchemaError, ValidationError): return False return True
def validate(self): """ Validate that this instance matches its schema. """ schema = Schema(self.__class__.SCHEMA) resolver = RefResolver.from_schema( schema, store=REGISTRY, ) validate(self, schema, resolver=resolver)
def validate(self, instance, schema_id, skip_http=True): """ Validate an instance against a registered schema. """ schema = self[schema_id] handlers = {} if skip_http: handlers.update( http=do_not_resolve, https=do_not_resolve, ) resolver = RefResolver.from_schema( schema, store=self, handlers=handlers, ) return validate(instance, schema, resolver=resolver)
class TestMapperExtensions(object): params = {'test_ext': [{'data': TENDER, 'result': RESULT}]} mapper = Mapper(MAPPING, RefResolver.from_schema(SCHEMA)) def test_ext(self, data, result): assert self.mapper.apply(data) == result data['bids'] = [{ 'id': 'id', 'status': 'active' }, { 'id': 'id', 'status': 'invalid.pre-qualification' }] assert self.mapper.apply(data)['bids']['details'] == [{ 'id': 'id', 'status': 'valid' }, { 'id': 'id', 'status': 'disqualified' }] data['shortlistedFirms'] = [{'name': 'name'}] assert (self.mapper.apply(data)['tender']['shortlistedFirms'] == data['shortlistedFirms']) data['cancellations'] = [{'cancellationOf': 'tender'}] assert self.mapper.apply(data)['tender']['pendingCancellation'] data['cancellations'].append({ 'cancellationOf': 'lot', 'relatedLot': 'lot_id' }) data['lots'] = [{'id': 'lot_id'}, {'id': 'spam'}] for lot in self.mapper.apply(data)['tender']['lots']: if lot['id'] == 'lot_id' and lot['pendingCancellation']: assert 1 break else: assert 0 data['guarantee'] = { 'amount': 1.5, 'currency': 'UAH', } data['lots'][0]['guarantee'] = data['guarantee'] assert self.mapper.apply( data)['tender']['guarantee'] == data['guarantee'] assert self.mapper.apply( data)['tender']['lots'][0]['guarantee'] == data['guarantee'] data['procuringEntity'] = {'identifier': {'id': 'id'}} assert self.mapper.apply(data)['parties'] == [{ 'identifier': { 'id': 'id' }, 'roles': ['procuringEntity'] }]
os.path.join(here, "settings.schema.json")) schema_store = { schema_table["global.schema.json"]["recipe"]["$id"]: schema_table["global.schema.json"]["recipe"], schema_table["compiler-v1.0.schema.json"]["recipe"]["$id"]: schema_table["compiler-v1.0.schema.json"]["recipe"], schema_table["script-v1.0.schema.json"]["recipe"]["$id"]: schema_table["script-v1.0.schema.json"]["recipe"], schema_table["definitions.schema.json"]["recipe"]["$id"]: schema_table["definitions.schema.json"]["recipe"], schema_table["settings.schema.json"]["recipe"]["$id"]: schema_table["settings.schema.json"]["recipe"], } resolver = RefResolver.from_schema( schema_table["definitions.schema.json"]["recipe"], store=schema_store) def custom_validator(recipe, schema): """This is a custom validator for validating JSON documents. We implement a custom resolver for finding json schemas locally by implementing a schema store. The input arguments ``recipe`` and ``schema`` is your input JSON recipe and schema content for validating the recipe. This method uses Draft7Validator for validating schemas. :param recipe: Input recipe as JSON document :type recipe: dict :param schema: Input JSON Schema content to validate JSON document :type schema: dict """
def refresolver(self): if not self._refresolver: self._refresolver = RefResolver.from_schema(self.__schema__) return self._refresolver
'schema': None }, 404: { 'headers': None, 'schema': None }, 405: { 'headers': None, 'schema': None } }, } scopes = {} resolver = RefResolver.from_schema(definitions) class Security(object): def __init__(self): super(Security, self).__init__() self._loader = lambda: [] @property def scopes(self): return self._loader() def scopes_loader(self, func): self._loader = func return func
def setUp(self): super().setUp() with open('schemas/system_profile/v1.yaml') as spec_yaml: self.specification = safe_load(spec_yaml) self.resolver = RefResolver.from_schema(self.specification)
def __init__(self, json_pointer=''): schema = load_schema(json_pointer=json_pointer) resolver = RefResolver.from_schema(load_schema()) self.validator = Draft4Validator(schema, resolver=resolver)
def setUp(self): self.data = TENDER self.mapper = Mapper(MAPPING, RefResolver.from_schema(SCHEMA))
def test_it_can_construct_a_base_uri_from_a_schema_without_id(self): schema = {} resolver = RefResolver.from_schema(schema) self.assertEqual(resolver.base_uri, "") self.assertEqual(resolver.referrer, schema)
def resolver(self): return RefResolver.from_schema(Swagger(self).as_dict())
def validate(self, subject, schema: Dict): schema = self._rewriter.rewrite(schema) store = self._schemas.get_schemas() resolver = RefResolver.from_schema(schema, store=store) validate(subject, schema, resolver=resolver)
def get_batch_validator() -> Validator: batch_schema = get_schema("batch_of_package_json") nested_schema = get_schema("package_json") store = get_schema_store() resolver = RefResolver.from_schema(nested_schema, store=store) return Draft7Validator(batch_schema, resolver=resolver)
def validate_subschema(data, schema_selector): schema = load_schema() resolver = RefResolver.from_schema(schema) format_checker = FormatChecker() request_schema = resolver.resolve_from_url(schema_selector) validate(data, request_schema, resolver=resolver, format_checker=format_checker)
import json from jsonschema import RefResolver from collections import deque, namedtuple import argparse # parse command line args arg_parser = argparse.ArgumentParser() arg_parser.add_argument('schema_path') arg_parser.add_argument('out_path') args = arg_parser.parse_args() # load Vega Lite schema and reference resolver with open(args.schema_path) as f: schema = json.load(f) resolver = RefResolver.from_schema(schema) resolve = lambda ref: resolver.resolve(ref)[1] # represents a node in the schema class Node(namedtuple('Node', ['schema', 'full_path'])): @property def path(self): # remove "anyOf"s and references return tuple(key for key in self.full_path if not (key.startswith("anyOf[") or key.startswith("#/"))) def children(node): """Return the children of a given node.
def setup_base_json_schema_resolver(context): definitions = json.loads( open(context.config.userdata['json_schemas'] + 'definitions.json', 'r').read().replace('\n', '')) return RefResolver.from_schema(definitions)
def get_tagged_batch_validator() -> Validator: schema = get_schema("tagged_batch") nested_schema = get_schema("cpe") store = get_schema_store() resolver = RefResolver.from_schema(nested_schema, store=store) return Draft7Validator(schema, resolver=resolver)
def test_it_can_construct_a_base_uri_from_a_schema(self): schema = {"id" : "foo"} resolver = RefResolver.from_schema(schema) self.assertEqual(resolver.base_uri, "foo") self.assertEqual(resolver.referrer, schema)
else: #如果校验器存在该主题ID而主题管理器没有,则说明是删除的 if not self._topic_manager.topic_dict.has_key(reload_id): if self._topic_validator_dict.has_key(reload_id): del self._topic_validator_dict[reload_id] else: validator_to_use = None try: schema_obj = self._topic_manager.topic_dict[reload_id][ 'schema_obj'] Draft4Validator.check_schema(schema_obj) validator_to_use = Draft4Validator( schema_obj, resolver=RefResolver.from_schema( schema_obj, handlers={ 'haizhi': self._haizhi_ref_resolver.resolve_url })) log.info( 'JsonSchemaValidator.init: Schema loaded successfully! topic.id[%s], topic.name[%s]' % (reload_id, self._topic_manager.topic_dict[reload_id] ['name'].encode('utf8'))) except jsonschema.SchemaError, se: validator_to_use = AlwaysFailValidator( reason= 'Schema is invalid!! topic.id[%s], topic.name[%s]' % (reload_id, self._topic_manager.topic_dict[reload_id])) # TODO: 这里是否应该继续抛出异常, 使得程序退出? self._topic_validator_dict[reload_id] = validator_to_use
def __init__(self, schema): self.resolver = RefResolver.from_schema(schema)