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 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)
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)
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)
def refresolver(self):
if not self._refresolver:
self._refresolver = RefResolver.from_schema(self.__schema__)
return self._refresolver
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)
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)
