コード例 #1
0
    def test_validates_registers_meta_schema_draft6_id(self):
        meta_schema_key = "meta schema $id"
        my_meta_schema = {u"$id": meta_schema_key}

        validators.create(
            meta_schema=my_meta_schema,
            version="my version",
        )

        self.assertIn(meta_schema_key, validators.meta_schemas)
コード例 #2
0
    def test_validates_registers_meta_schema_id(self):
        meta_schema_key = "meta schema id"
        my_meta_schema = {u"id": meta_schema_key}

        validators.create(
            meta_schema=my_meta_schema,
            version="my version",
            id_of=lambda s: s.get("id", ""),
        )

        self.assertIn(meta_schema_key, validators.meta_schemas)
コード例 #3
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_providing_default_types_with_type_checker_errors(self):
        with self.assertRaises(TypeError) as e:
            validators.create(
                meta_schema={},
                validators={},
                default_types={"foo": object},
                type_checker=TypeChecker(),
            )

        self.assertIn(
            "Do not specify default_types when providing a type checker",
            str(e.exception),
        )
        self.assertFalse(self.flushWarnings())
コード例 #4
0
    def test_providing_default_types_with_type_checker_errors(self):
        with self.assertRaises(TypeError) as e:
            validators.create(
                meta_schema={},
                validators={},
                default_types={"foo": object},
                type_checker=TypeChecker(),
            )

        self.assertIn(
            "Do not specify default_types when providing a type checker",
            str(e.exception),
        )
        self.assertFalse(self.flushWarnings())
コード例 #5
0
def get_jsonschema_validator():
    """Get metaschema validator and format checker

    Older versions of jsonschema require some compatibility changes.

    @returns: Tuple: (jsonschema.Validator, FormatChecker)
    @raises: ImportError when jsonschema is not present
    """
    from jsonschema import Draft4Validator, FormatChecker
    from jsonschema.validators import create

    # Allow for bytes to be presented as an acceptable valid value for string
    # type jsonschema attributes in cloud-init's schema.
    # This allows #cloud-config to provide valid yaml "content: !!binary | ..."

    strict_metaschema = deepcopy(Draft4Validator.META_SCHEMA)
    strict_metaschema["additionalProperties"] = False

    # This additional label allows us to specify a different name
    # than the property key when generating docs.
    # This is especially useful when using a "patternProperties" regex,
    # otherwise the property label in the generated docs will be a
    # regular expression.
    # http://json-schema.org/understanding-json-schema/reference/object.html#pattern-properties
    strict_metaschema["properties"]["label"] = {"type": "string"}

    if hasattr(Draft4Validator, "TYPE_CHECKER"):  # jsonschema 3.0+
        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
            "string", is_schema_byte_string
        )
        cloudinitValidator = create(
            meta_schema=strict_metaschema,
            validators=Draft4Validator.VALIDATORS,
            version="draft4",
            type_checker=type_checker,
        )
    else:  # jsonschema 2.6 workaround
        types = Draft4Validator.DEFAULT_TYPES  # pylint: disable=E1101
        # Allow bytes as well as string (and disable a spurious unsupported
        # assignment-operation pylint warning which appears because this
        # code path isn't written against the latest jsonschema).
        types["string"] = (str, bytes)  # pylint: disable=E1137
        cloudinitValidator = create(  # pylint: disable=E1123
            meta_schema=strict_metaschema,
            validators=Draft4Validator.VALIDATORS,
            version="draft4",
            default_types=types,
        )
    return (cloudinitValidator, FormatChecker)
コード例 #6
0
ファイル: schema.py プロジェクト: bsipocz/pyasdf
def check_schema(schema):
    """
    Check a given schema to make sure it is valid YAML schema.
    """
    # We also want to validate the "default" values in the schema
    # against the schema itself.  jsonschema as a library doesn't do
    # this on its own.

    def validate_default(validator, default, instance, schema):
        if not validator.is_type(instance, "object"):
            return

        if "default" in instance:
            with instance_validator.resolver.in_scope(scope):
                for err in instance_validator.iter_errors(instance["default"], instance):
                    yield err

    VALIDATORS = util.HashableDict(mvalidators.Draft4Validator.VALIDATORS.copy())
    VALIDATORS.update({"default": validate_default})

    meta_schema = load_schema(YAML_SCHEMA_METASCHEMA_ID, mresolver.default_url_mapping)

    resolver = _make_resolver(mresolver.default_url_mapping)

    cls = mvalidators.create(meta_schema=meta_schema, validators=VALIDATORS)
    validator = cls(meta_schema, resolver=resolver)

    instance_validator = mvalidators.Draft4Validator(schema, resolver=resolver)
    scope = schema.get("id", "")

    validator.validate(schema, _schema=meta_schema)
コード例 #7
0
ファイル: schema.py プロジェクト: nden/pyasdf
def create_validator():
    global _created_validator
    if _created_validator:
        return

    validator = validators.create(
        meta_schema=load_schema(
            'http://stsci.edu/schemas/yaml-schema/draft-01',
            mresolver.UrlMapping()),
        validators=YAML_VALIDATORS,
        version=str('yaml schema draft 1'))
    validator.orig_iter_errors = validator.iter_errors

    # We can't validate anything that looks like an external
    # reference, since we don't have the actual content, so we
    # just have to defer it for now.  If the user cares about
    # complete validation, they can call
    # `AsdfFile.resolve_references`.
    def iter_errors(self, instance, _schema=None):
        if ((isinstance(instance, dict) and '$ref' in instance) or
            isinstance(instance, reference.Reference)):
            return

        for x in self.orig_iter_errors(instance, _schema=_schema):
            yield x

    validator.iter_errors = iter_errors
    _created_validator = True
コード例 #8
0
 def setUp(self):
     all_validators = dict(validators.Draft7Validator.VALIDATORS)
     all_validators['async_valid'] = async_validator
     self.validator = validators.create(
         meta_schema=validators.Draft7Validator.META_SCHEMA,
         validators=all_validators,
     )({})
コード例 #9
0
ファイル: schema.py プロジェクト: nden/pyasdf
def create_validator():
    global _created_validator
    if _created_validator:
        return

    validator = validators.create(meta_schema=load_schema(
        'http://stsci.edu/schemas/yaml-schema/draft-01',
        mresolver.UrlMapping()),
                                  validators=YAML_VALIDATORS,
                                  version=str('yaml schema draft 1'))
    validator.orig_iter_errors = validator.iter_errors

    # We can't validate anything that looks like an external
    # reference, since we don't have the actual content, so we
    # just have to defer it for now.  If the user cares about
    # complete validation, they can call
    # `AsdfFile.resolve_references`.
    def iter_errors(self, instance, _schema=None):
        if ((isinstance(instance, dict) and '$ref' in instance)
                or isinstance(instance, reference.Reference)):
            return

        for x in self.orig_iter_errors(instance, _schema=_schema):
            yield x

    validator.iter_errors = iter_errors
    _created_validator = True
コード例 #10
0
ファイル: schema.py プロジェクト: harshmathur1990/asdf
def check_schema(schema):
    """
    Check a given schema to make sure it is valid YAML schema.
    """

    # We also want to validate the "default" values in the schema
    # against the schema itself.  jsonschema as a library doesn't do
    # this on its own.

    def validate_default(validator, default, instance, schema):
        if not validator.is_type(instance, 'object'):
            return

        if 'default' in instance:
            with instance_validator.resolver.in_scope(scope):
                for err in instance_validator.iter_errors(
                        instance['default'], instance):
                    yield err

    VALIDATORS = util.HashableDict(
        mvalidators.Draft4Validator.VALIDATORS.copy())
    VALIDATORS.update({'default': validate_default})

    meta_schema = load_schema(YAML_SCHEMA_METASCHEMA_ID,
                              mresolver.default_resolver)

    resolver = _make_resolver(mresolver.default_resolver)

    cls = mvalidators.create(meta_schema=meta_schema, validators=VALIDATORS)
    validator = cls(meta_schema, resolver=resolver)

    instance_validator = mvalidators.Draft4Validator(schema, resolver=resolver)
    scope = schema.get('id', '')

    validator.validate(schema, _schema=meta_schema)
コード例 #11
0
ファイル: schema.py プロジェクト: aarchiba/pyasdf
def _create_validator():
    global _validator
    if _validator is not None:
        return _validator

    validator = validators.create(
        meta_schema=load_schema(
            'http://stsci.edu/schemas/yaml-schema/draft-01',
            mresolver.default_url_mapping),
        validators=YAML_VALIDATORS)
    validator.orig_iter_errors = validator.iter_errors

    # We can't validate anything that looks like an external
    # reference, since we don't have the actual content, so we
    # just have to defer it for now.  If the user cares about
    # complete validation, they can call
    # `AsdfFile.resolve_references`.
    def iter_errors(self, instance, _schema=None, _seen=set()):
        if id(instance) in _seen:
            return

        if _schema is None:
            schema = self.schema
        else:
            schema = _schema

        if ((isinstance(instance, dict) and '$ref' in instance) or
            isinstance(instance, reference.Reference)):
            return

        if _schema is None:
            tag = tagged.get_tag(instance)
            if tag is not None:
                schema_path = self.ctx.tag_to_schema_resolver(tag)
                if schema_path != tag:
                    s = load_schema(schema_path, self.ctx.url_mapping)
                    if s:
                        with self.resolver.in_scope(schema_path):
                            for x in self.orig_iter_errors(instance, s):
                                yield x

            if isinstance(instance, dict):
                new_seen = _seen | set([id(instance)])
                for val in six.itervalues(instance):
                    for x in self.iter_errors(val, _seen=new_seen):
                        yield x

            elif isinstance(instance, list):
                new_seen = _seen | set([id(instance)])
                for val in instance:
                    for x in self.iter_errors(val, _seen=new_seen):
                        yield x
        else:
            for x in self.orig_iter_errors(instance, _schema=schema):
                yield x

    validator.iter_errors = iter_errors

    _validator = validator
    return validator
コード例 #12
0
 def test_if_a_version_is_provided_it_is_registered(self):
     Validator = validators.create(
         meta_schema={u"$id": "something"},
         version="my version",
     )
     self.addCleanup(validators.meta_schemas.pop, "something")
     self.assertEqual(Validator.__name__, "MyVersionValidator")
コード例 #13
0
def validate_homology_inputs(cromwell_inputs):
    with pkg_resources.path("validation", "homology.schema.json") as schema_file:
        with open(schema_file, 'r') as schema:
            schema = json.load(schema)
    all_validators = dict(Draft7Validator.VALIDATORS)
    reat_validator = validators.create(meta_schema=schema, validators=all_validators)
    reat_validator(schema).validate(cromwell_inputs)
コード例 #14
0
def validate(data, schema):
    from jsonschema import RefResolver, validators, FormatChecker, Draft4Validator
    from urllib.parse import urljoin
    from snakemake.io import _load_configfile

    schemafile = schema
    schema = _load_configfile(schema, filetype="Schema")

    resolver = RefResolver(
        urljoin('file:', schemafile),
        schema,
        handlers={
            'file': lambda uri: _load_configfile(re.sub("^file://", "", uri))
        })

    format_checker = FormatChecker()

    def path_exists(validator, properties, instance, schema):
        if properties and not Path(instance).expanduser().exists():
            yield jsonschema.exceptions.ValidationError(
                "{} does not exist".format(instance))

    @format_checker.checks('file')
    def check_filepath(value):
        path = Path(value)
        return path.is_file() if path.exists() else True

    @format_checker.checks('directory')
    def check_directory(value):
        path = Path(value)
        return path.is_dir() if path.exists() else True

    all_validators = dict(Draft4Validator.VALIDATORS)
    all_validators['must_exist'] = path_exists

    Validator = validators.create(meta_schema=Draft4Validator.META_SCHEMA,
                                  validators=all_validators)

    validator = Validator(schema,
                          resolver=resolver,
                          format_checker=format_checker)

    errors = []

    if not isinstance(data, dict):
        for row in data.to_dict('records'):
            print(row)
            for ve in validator.iter_errors(row):
                key = ve.relative_path.pop() if len(
                    ve.relative_path) > 0 else None
                errors.append(MarsValidationError(ve.instance, key,
                                                  ve.message))
    else:
        for ve in validator.iter_errors(data):
            key = ve.relative_path.pop() if len(ve.relative_path) > 0 else None
            errors.append(MarsValidationError(ve.instance, key, ve.message))
    return errors
コード例 #15
0
ファイル: schema.py プロジェクト: spacetelescope/asdf
def _create_validator(validators=YAML_VALIDATORS):
    meta_schema = load_schema(YAML_SCHEMA_METASCHEMA_ID, default_ext_resolver)
    base_cls = mvalidators.create(meta_schema=meta_schema, validators=validators)

    class ASDFValidator(base_cls):
        DEFAULT_TYPES = base_cls.DEFAULT_TYPES.copy()
        DEFAULT_TYPES['array'] = (list, tuple)

        def iter_errors(self, instance, _schema=None, _seen=set()):
            # We can't validate anything that looks like an external reference,
            # since we don't have the actual content, so we just have to defer
            # it for now.  If the user cares about complete validation, they
            # can call `AsdfFile.resolve_references`.
            if id(instance) in _seen:
                return

            if _schema is None:
                schema = self.schema
            else:
                schema = _schema

            if ((isinstance(instance, dict) and '$ref' in instance) or
                    isinstance(instance, reference.Reference)):
                return

            if _schema is None:
                tag = getattr(instance, '_tag', None)
                if tag is not None:
                    schema_path = self.ctx.resolver(tag)
                    if schema_path != tag:
                        try:
                            s = load_schema(schema_path, self.ctx.resolver)
                        except FileNotFoundError:
                            msg = "Unable to locate schema file for '{}': '{}'"
                            warnings.warn(msg.format(tag, schema_path))
                            s = {}
                        if s:
                            with self.resolver.in_scope(schema_path):
                                for x in super(ASDFValidator, self).iter_errors(instance, s):
                                    yield x

                if isinstance(instance, dict):
                    new_seen = _seen | set([id(instance)])
                    for val in instance.values():
                        for x in self.iter_errors(val, _seen=new_seen):
                            yield x

                elif isinstance(instance, list):
                    new_seen = _seen | set([id(instance)])
                    for val in instance:
                        for x in self.iter_errors(val, _seen=new_seen):
                            yield x
            else:
                for x in super(ASDFValidator, self).iter_errors(instance, _schema=schema):
                    yield x

    return ASDFValidator
コード例 #16
0
 def test_if_a_version_is_provided_it_is_registered(self):
     with mock.patch("jsonschema.validators.validates") as validates:
         validates.side_effect = lambda version: lambda cls: cls
         Validator = validators.create(
             meta_schema={u"id": ""},
             version="my version",
         )
     validates.assert_called_once_with("my version")
     self.assertEqual(Validator.__name__, "MyVersionValidator")
コード例 #17
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
 def test_if_a_version_is_provided_it_is_registered(self):
     with mock.patch("jsonschema.validators.validates") as validates:
         validates.side_effect = lambda version: lambda cls: cls
         Validator = validators.create(
             meta_schema={u"id": ""},
             version="my version",
         )
     validates.assert_called_once_with("my version")
     self.assertEqual(Validator.__name__, "MyVersionValidator")
コード例 #18
0
ファイル: schema.py プロジェクト: harshmathur1990/asdf
def _create_validator(validators=YAML_VALIDATORS):
    meta_schema = load_schema(YAML_SCHEMA_METASCHEMA_ID,
                              mresolver.default_resolver)
    base_cls = mvalidators.create(meta_schema=meta_schema,
                                  validators=validators)

    class ASDFValidator(base_cls):
        DEFAULT_TYPES = base_cls.DEFAULT_TYPES.copy()
        DEFAULT_TYPES['array'] = (list, tuple)

        def iter_errors(self, instance, _schema=None, _seen=set()):
            # We can't validate anything that looks like an external reference,
            # since we don't have the actual content, so we just have to defer
            # it for now.  If the user cares about complete validation, they
            # can call `AsdfFile.resolve_references`.
            if id(instance) in _seen:
                return

            if _schema is None:
                schema = self.schema
            else:
                schema = _schema

            if ((isinstance(instance, dict) and '$ref' in instance)
                    or isinstance(instance, reference.Reference)):
                return

            if _schema is None:
                tag = getattr(instance, '_tag', None)
                if tag is not None:
                    schema_path = self.ctx.resolver(tag)
                    if schema_path != tag:
                        s = load_schema(schema_path, self.ctx.resolver)
                        if s:
                            with self.resolver.in_scope(schema_path):
                                for x in super(ASDFValidator,
                                               self).iter_errors(instance, s):
                                    yield x

                if isinstance(instance, dict):
                    new_seen = _seen | set([id(instance)])
                    for val in instance.values():
                        for x in self.iter_errors(val, _seen=new_seen):
                            yield x

                elif isinstance(instance, list):
                    new_seen = _seen | set([id(instance)])
                    for val in instance:
                        for x in self.iter_errors(val, _seen=new_seen):
                            yield x
            else:
                for x in super(ASDFValidator,
                               self).iter_errors(instance, _schema=schema):
                    yield x

    return ASDFValidator
コード例 #19
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_providing_explicit_type_checker_does_not_warn(self):
        Validator = validators.create(
            meta_schema={},
            validators={},
            type_checker=TypeChecker(),
        )
        self.assertFalse(self.flushWarnings())

        Validator({})
        self.assertFalse(self.flushWarnings())
コード例 #20
0
    def test_providing_explicit_type_checker_does_not_warn(self):
        Validator = validators.create(
            meta_schema={},
            validators={},
            type_checker=TypeChecker(),
        )
        self.assertFalse(self.flushWarnings())

        Validator({})
        self.assertFalse(self.flushWarnings())
コード例 #21
0
def validate_transcriptome_inputs(cromwell_inputs):
    with pkg_resources.path("validation",
                            "transcriptome.schema.json") as schema_file:
        with open(schema_file, 'r') as schema:
            reat_schema = json.load(schema)
    all_validators = dict(Draft7Validator.VALIDATORS)
    all_validators["is_name"] = is_valid_name
    reat_validator = validators.create(meta_schema=reat_schema,
                                       validators=all_validators)
    reat_validator(reat_schema).validate(cromwell_inputs)
コード例 #22
0
    def setUp(self):
        self.meta_schema = {u"properties": {u"smelly": {}}}
        self.smelly = mock.MagicMock()
        self.validators = {u"smelly": self.smelly}
        self.types = {u"dict": dict}
        self.Validator = create(meta_schema=self.meta_schema, validators=self.validators, default_types=self.types)

        self.validator_value = 12
        self.schema = {u"smelly": self.validator_value}
        self.validator = self.Validator(self.schema)
コード例 #23
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
 def test_custom_validator(self):
     Validator = validators.create(
         meta_schema={"id": "meta schema id"},
         version="12",
     )
     schema = {"$schema": "meta schema id"}
     self.assertIs(
         validators.validator_for(schema),
         Validator,
     )
コード例 #24
0
 def test_custom_validator_draft6(self):
     Validator = validators.create(
         meta_schema={"$id": "meta schema $id"},
         version="13",
     )
     schema = {"$schema": "meta schema $id"}
     self.assertIs(
         validators.validator_for(schema),
         Validator,
     )
コード例 #25
0
    def test_default_types_update_type_checker(self):
        Validator = validators.create(meta_schema=self.meta_schema,
                                      validators=self.validators,
                                      default_types={u"array": list})

        self.assertEqual(set(Validator.DEFAULT_TYPES), {u"array"})
        Extended = validators.extend(
            Validator, type_checker=Validator.TYPE_CHECKER.remove(u"array"))

        self.assertEqual(set(Extended.DEFAULT_TYPES), {})
コード例 #26
0
 def test_custom_validator(self):
     Validator = validators.create(
         meta_schema={"id": "meta schema id"},
         version="12",
         id_of=lambda s: s.get("id", ""),
     )
     schema = {"$schema": "meta schema id"}
     self.assertIs(
         validators.validator_for(schema),
         Validator,
     )
コード例 #27
0
    def validator(self):
        def is_unique(validator, value, instance, schema):
            if is_exists(self.store, key=value, value=instance):
                yield ValidationError(f"`{value}` `{instance}` already exists")

        all_validators = dict(Draft4Validator.VALIDATORS)
        all_validators["is_unique"] = is_unique

        MyValidator = validators.create(
            meta_schema=Draft4Validator.META_SCHEMA, validators=all_validators)

        return MyValidator(self.schema)
コード例 #28
0
ファイル: schema.py プロジェクト: astrofrog/pyasdf
def _create_validator(_validators=YAML_VALIDATORS):
    validator = validators.create(meta_schema=load_schema(
        'http://stsci.edu/schemas/yaml-schema/draft-01',
        mresolver.default_url_mapping),
                                  validators=_validators)
    validator.orig_iter_errors = validator.iter_errors

    # We can't validate anything that looks like an external
    # reference, since we don't have the actual content, so we
    # just have to defer it for now.  If the user cares about
    # complete validation, they can call
    # `AsdfFile.resolve_references`.
    def iter_errors(self, instance, _schema=None, _seen=set()):
        if id(instance) in _seen:
            return

        if _schema is None:
            schema = self.schema
        else:
            schema = _schema

        if ((isinstance(instance, dict) and '$ref' in instance)
                or isinstance(instance, reference.Reference)):
            return

        if _schema is None:
            tag = tagged.get_tag(instance)
            if tag is not None:
                schema_path = self.ctx.tag_to_schema_resolver(tag)
                if schema_path != tag:
                    s = load_schema(schema_path, self.ctx.url_mapping)
                    if s:
                        with self.resolver.in_scope(schema_path):
                            for x in self.orig_iter_errors(instance, s):
                                yield x

            if isinstance(instance, dict):
                new_seen = _seen | set([id(instance)])
                for val in six.itervalues(instance):
                    for x in self.iter_errors(val, _seen=new_seen):
                        yield x

            elif isinstance(instance, list):
                new_seen = _seen | set([id(instance)])
                for val in instance:
                    for x in self.iter_errors(val, _seen=new_seen):
                        yield x
        else:
            for x in self.orig_iter_errors(instance, _schema=schema):
                yield x

    validator.iter_errors = iter_errors
    return validator
コード例 #29
0
    def test_default_types_used_if_no_type_checker_given(self):
        Validator = validators.create(
            meta_schema=self.meta_schema,
            validators=self.validators,
        )

        expected_types = {
            u"array", u"boolean", u"integer", u"null", u"number", u"object",
            u"string"
        }

        self.assertEqual(set(Validator.DEFAULT_TYPES), expected_types)
コード例 #30
0
    def setUp(self):
        self.meta_schema = {u"properties": {u"smelly": {}}}
        self.smelly = mock.MagicMock()
        self.validators = {u"smelly": self.smelly}
        self.type_checker = TypeChecker()
        self.Validator = validators.create(meta_schema=self.meta_schema,
                                           validators=self.validators,
                                           type_checker=self.type_checker)

        self.validator_value = 12
        self.schema = {u"smelly": self.validator_value}
        self.validator = self.Validator(self.schema)
コード例 #31
0
    def validator(self):
        def unique(validator, value, instance, schema):
            if store.contains(self.__storage_name, key=value, value=instance):
                yield ValidationError(
                    f"`{value}` `{instance}` already exists.")

        all_validators = dict(Draft4Validator.VALIDATORS)
        all_validators["unique"] = unique

        MyValidator = validators.create(
            meta_schema=Draft4Validator.META_SCHEMA, validators=all_validators)

        return MyValidator(self.validation_schema)
コード例 #32
0
    def setUp(self):
        self.addCleanup(
            self.assertEqual,
            validators.meta_schemas,
            dict(validators.meta_schemas),
        )

        self.meta_schema = {u"$id": "some://meta/schema"}
        self.validators = {u"startswith": startswith}
        self.type_checker = TypeChecker()
        self.Validator = validators.create(meta_schema=self.meta_schema,
                                           validators=self.validators,
                                           type_checker=self.type_checker)
コード例 #33
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_default_types_used_if_no_type_checker_given(self):
        Validator = validators.create(
            meta_schema=self.meta_schema,
            validators=self.validators,
        )

        expected_types = {u"array", u"boolean", u"integer", u"null", u"number",
                          u"object", u"string"}

        self.assertEqual(set(Validator.DEFAULT_TYPES), expected_types)

        self.assertEqual(set(Validator.TYPE_CHECKER._type_checkers),
                         expected_types)
コード例 #34
0
ファイル: schema.py プロジェクト: bsipocz/pyasdf
def _create_validator(validators=YAML_VALIDATORS):
    meta_schema = load_schema(YAML_SCHEMA_METASCHEMA_ID, mresolver.default_url_mapping)
    base_cls = mvalidators.create(meta_schema=meta_schema, validators=validators)

    class ASDFValidator(base_cls):
        DEFAULT_TYPES = base_cls.DEFAULT_TYPES.copy()
        DEFAULT_TYPES["array"] = (list, tuple)

        def iter_errors(self, instance, _schema=None, _seen=set()):
            # We can't validate anything that looks like an external reference,
            # since we don't have the actual content, so we just have to defer
            # it for now.  If the user cares about complete validation, they
            # can call `AsdfFile.resolve_references`.
            if id(instance) in _seen:
                return

            if _schema is None:
                schema = self.schema
            else:
                schema = _schema

            if (isinstance(instance, dict) and "$ref" in instance) or isinstance(instance, reference.Reference):
                return

            if _schema is None:
                tag = getattr(instance, "_tag", None)
                if tag is not None:
                    schema_path = self.ctx.tag_to_schema_resolver(tag)
                    if schema_path != tag:
                        s = load_schema(schema_path, self.ctx.url_mapping)
                        if s:
                            with self.resolver.in_scope(schema_path):
                                for x in super(ASDFValidator, self).iter_errors(instance, s):
                                    yield x

                if isinstance(instance, dict):
                    new_seen = _seen | set([id(instance)])
                    for val in six.itervalues(instance):
                        for x in self.iter_errors(val, _seen=new_seen):
                            yield x

                elif isinstance(instance, list):
                    new_seen = _seen | set([id(instance)])
                    for val in instance:
                        for x in self.iter_errors(val, _seen=new_seen):
                            yield x
            else:
                for x in super(ASDFValidator, self).iter_errors(instance, _schema=schema):
                    yield x

    return ASDFValidator
コード例 #35
0
def validate_cloudconfig_schema(config, schema, strict=False):
    """Validate provided config meets the schema definition.

    @param config: Dict of cloud configuration settings validated against
        schema.
    @param schema: jsonschema dict describing the supported schema definition
       for the cloud config module (config.cc_*).
    @param strict: Boolean, when True raise SchemaValidationErrors instead of
       logging warnings.

    @raises: SchemaValidationError when provided config does not validate
        against the provided schema.
    """
    try:
        from jsonschema import Draft4Validator, FormatChecker
        from jsonschema.validators import create, extend
    except ImportError:
        logging.debug(
            'Ignoring schema validation. python-jsonschema is not present')
        return

    # Allow for bytes to be presented as an acceptable valid value for string
    # type jsonschema attributes in cloud-init's schema.
    # This allows #cloud-config to provide valid yaml "content: !!binary | ..."
    if hasattr(Draft4Validator, 'TYPE_CHECKER'):  # jsonschema 3.0+
        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
            'string', is_schema_byte_string)
        cloudinitValidator = extend(Draft4Validator, type_checker=type_checker)
    else:  # jsonschema 2.6 workaround
        types = Draft4Validator.DEFAULT_TYPES
        # Allow bytes as well as string (and disable a spurious
        # unsupported-assignment-operation pylint warning which appears because
        # this code path isn't written against the latest jsonschema).
        types['string'] = (str, bytes)  # pylint: disable=E1137
        cloudinitValidator = create(
            meta_schema=Draft4Validator.META_SCHEMA,
            validators=Draft4Validator.VALIDATORS,
            version="draft4",
            default_types=types)
    validator = cloudinitValidator(schema, format_checker=FormatChecker())
    errors = ()
    for error in sorted(validator.iter_errors(config), key=lambda e: e.path):
        path = '.'.join([str(p) for p in error.path])
        errors += ((path, error.message),)
    if errors:
        if strict:
            raise SchemaValidationError(errors)
        else:
            messages = ['{0}: {1}'.format(k, msg) for k, msg in errors]
            logging.warning('Invalid config:\n%s', '\n'.join(messages))
コード例 #36
0
    def __init__(self, document, scheme):
        self.document = document
        self.scheme = scheme

        title = scheme.get('title') or 'Scheme'
        self.title = 'Invalid ' + title
        all_validators = dict(Draft4Validator.VALIDATORS)

        MyValidator = validators.create(
            meta_schema=Draft4Validator.META_SCHEMA, validators=all_validators)
        format_checker = FormatChecker()

        self.validator = MyValidator(self.scheme,
                                     format_checker=format_checker)
コード例 #37
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_default_types_update_type_checker(self):
        Validator = validators.create(
            meta_schema=self.meta_schema,
            validators=self.validators,
            default_types={u"array": list}
        )

        self.assertEqual(set(Validator.DEFAULT_TYPES), {u"array"})
        Extended = validators.extend(
            Validator,
            type_checker=Validator.TYPE_CHECKER.remove(u"array")
        )

        self.assertEqual(set(Extended.DEFAULT_TYPES), {})
コード例 #38
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def setUp(self):
        self.meta_schema = {u"properties": {u"smelly": {}}}
        self.smelly = mock.MagicMock()
        self.validators = {u"smelly": self.smelly}
        self.type_checker = TypeChecker()
        self.Validator = validators.create(
            meta_schema=self.meta_schema,
            validators=self.validators,
            type_checker=self.type_checker
        )

        self.validator_value = 12
        self.schema = {u"smelly": self.validator_value}
        self.validator = self.Validator(self.schema)
コード例 #39
0
    def setUp(self):
        self.meta_schema = {u"properties": {u"smelly": {}}}
        self.smelly = mock.MagicMock()
        self.validators = {u"smelly": self.smelly}
        self.types = {u"dict": dict}
        self.Validator = create(
            meta_schema=self.meta_schema,
            validators=self.validators,
            default_types=self.types,
        )

        self.validator_value = 12
        self.schema = {u"smelly": self.validator_value}
        self.validator = self.Validator(self.schema)
コード例 #40
0
    def test_accessing_default_types_warns(self):
        Validator = validators.create(meta_schema={}, validators={})
        self.assertFalse(self.flushWarnings())

        self.assertWarns(
            DeprecationWarning,
            ("The DEFAULT_TYPES attribute is deprecated. "
             "See the type checker attached to this validator instead."),
            # https://tm.tl/9363 :'(
            sys.modules[self.assertWarns.__module__].__file__,
            getattr,
            Validator,
            "DEFAULT_TYPES",
        )
コード例 #41
0
ファイル: vocabs.py プロジェクト: shunsunsun/discovery-app
def get_validator(schema, default=False):
    """return a validator supporting "vocabulary" rule,
       return a default validator if default is True.
    """
    if default:
        return Draft7Validator(schema)

    all_validators = dict(Draft7Validator.VALIDATORS)
    all_validators['vocabulary'] = is_controlled_vocabulary

    VocabularyValidator = validators.create(
        meta_schema=Draft7Validator.META_SCHEMA, validators=all_validators)

    vocab_validator = VocabularyValidator(schema)
    return vocab_validator
コード例 #42
0
 def __init__(self, config: TransformConfig):
     """
     Initialize TypeTransformer instance.
     :param config Transform config that would be applied to object
     """
     if TransformConfig.NoTransform in config and config != TransformConfig.NoTransform:
         raise Exception("NoTransform option cannot be combined with other flags.")
     self._config = config
     all_validators = {
         key: self.__get_normalizer(key, orig_validator)
         for key, orig_validator in Draft7Validator.VALIDATORS.items()
         # Do not validate field we do not transform for maximum performance.
         if key in ["type", "array", "$ref", "properties", "items"]
     }
     self._normalizer = validators.create(meta_schema=Draft7Validator.META_SCHEMA, validators=all_validators)
コード例 #43
0
    def test_providing_types_to_init_warns(self):
        Validator = validators.create(meta_schema={}, validators={})
        self.assertFalse(self.flushWarnings())

        self.assertWarns(
            category=DeprecationWarning,
            message=("The types argument is deprecated. "
                     "Provide a type_checker to jsonschema.validators.extend "
                     "instead."),
            # https://tm.tl/9363 :'(
            filename=sys.modules[self.assertWarns.__module__].__file__,
            f=Validator,
            schema={},
            types={"bar": object},
        )
コード例 #44
0
ファイル: validator.py プロジェクト: 650elx/middleware
    def extend(validator, validators, version=None):
        all_validators = dict(validator.VALIDATORS)
        all_validators.update(validators)
        all_types = dict(validator.DEFAULT_TYPES)
        all_types.update({
            "fd": FileDescriptor,
            "binary": bytes,
            "datetime": datetime.datetime
        })

        return create(
            meta_schema=validator.META_SCHEMA,
            validators=all_validators,
            version=version,
            default_types=all_types,
        )
コード例 #45
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_accessing_default_types_warns(self):
        Validator = validators.create(meta_schema={}, validators={})
        self.assertFalse(self.flushWarnings())

        self.assertWarns(
            DeprecationWarning,
            (
                "The DEFAULT_TYPES attribute is deprecated. "
                "See the type checker attached to this validator instead."
            ),
            # https://tm.tl/9363 :'(
            sys.modules[self.assertWarns.__module__].__file__,

            getattr,
            Validator,
            "DEFAULT_TYPES",
        )
コード例 #46
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_providing_types_to_init_warns(self):
        Validator = validators.create(meta_schema={}, validators={})
        self.assertFalse(self.flushWarnings())

        self.assertWarns(
            category=DeprecationWarning,
            message=(
                "The types argument is deprecated. "
                "Provide a type_checker to jsonschema.validators.extend "
                "instead."
            ),
            # https://tm.tl/9363 :'(
            filename=sys.modules[self.assertWarns.__module__].__file__,

            f=Validator,
            schema={},
            types={"bar": object},
        )
コード例 #47
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_types_update_type_checker(self):
        tc = TypeChecker()
        tc = tc.redefine(u"integer", _types.is_integer)
        Validator = validators.create(
            meta_schema=self.meta_schema,
            validators=self.validators,
            type_checker=tc,
        )

        v = Validator({})
        self.assertEqual(
            v.TYPE_CHECKER,
            TypeChecker(type_checkers={u"integer": _types.is_integer}),
        )

        v = Validator({}, types={u"array": list})
        self.assertEqual(
            v.TYPE_CHECKER,
            TypeChecker(type_checkers={u"array": _types.is_array}),
        )
コード例 #48
0
ファイル: schema.py プロジェクト: astrofrog/pyasdf
def check_schema(schema):
    """
    Check a given schema to make sure it is valid YAML schema.
    """
    # We also want to validate the "default" values in the schema
    # against the schema itself.  jsonschema as a library doesn't do
    # this on its own.

    def validate_default(validator, default, instance, schema):
        if not validator.is_type(instance, 'object'):
            return

        if 'default' in instance:
            with instance_validator.resolver.in_scope(scope):
                for err in instance_validator.iter_errors(
                        instance['default'], instance):
                    yield err

    VALIDATORS = util.HashableDict(
        validators.Draft4Validator.VALIDATORS.copy())
    VALIDATORS.update({
        'default': validate_default
    })

    meta_schema = load_schema(
        'http://stsci.edu/schemas/yaml-schema/draft-01',
        mresolver.default_url_mapping)

    resolver = _make_resolver(mresolver.default_url_mapping)

    cls = validators.create(meta_schema=meta_schema,
                            validators=VALIDATORS)
    validator = cls(meta_schema, resolver=resolver)

    instance_validator = validators.Draft4Validator(schema, resolver=resolver)
    scope = schema.get('id', '')

    validator.validate(schema, _schema=meta_schema)
コード例 #49
0
ファイル: schema.py プロジェクト: spacetelescope/asdf
def check_schema(schema):
    """
    Check a given schema to make sure it is valid YAML schema.
    """
    # We also want to validate the "default" values in the schema
    # against the schema itself.  jsonschema as a library doesn't do
    # this on its own.

    def validate_default(validator, default, instance, schema):
        if not validator.is_type(instance, 'object'):
            return

        if 'default' in instance:
            with instance_validator.resolver.in_scope(scope):
                for err in instance_validator.iter_errors(
                        instance['default'], instance):
                    yield err

    VALIDATORS = util.HashableDict(
        mvalidators.Draft4Validator.VALIDATORS.copy())
    VALIDATORS.update({
        'default': validate_default
    })

    meta_schema_id = schema.get('$schema', YAML_SCHEMA_METASCHEMA_ID)
    meta_schema = load_schema(meta_schema_id, default_ext_resolver)

    resolver = _make_resolver(default_ext_resolver)

    cls = mvalidators.create(meta_schema=meta_schema,
                             validators=VALIDATORS)
    validator = cls(meta_schema, resolver=resolver)

    instance_validator = mvalidators.Draft4Validator(schema, resolver=resolver)
    scope = schema.get('id', '')

    validator.validate(schema, _schema=meta_schema)
コード例 #50
0
ファイル: test_validators.py プロジェクト: clarete/jsonschema
 def test_if_a_version_is_not_provided_it_is_not_registered(self):
     with mock.patch("jsonschema.validators.validates") as validates:
         create(meta_schema={"id" : "id"})
     self.assertFalse(validates.called)
コード例 #51
0
ファイル: func_test.py プロジェクト: Skycle/Tornado-JSON
class DummyView(requesthandlers.ViewHandler):
    """Dummy ViewHandler for coverage"""
    def delete(self):
        # Reference db_conn to test for AttributeError
        self.db_conn

meta_schema = Draft4Validator.META_SCHEMA.copy()
meta_schema['definitions']["simpleTypes"]['enum'].append('int')

default_types = Draft4Validator.DEFAULT_TYPES.copy()
default_types['int'] = int


ExtendedDraft4Validator = create(meta_schema,
                                 Draft4Validator.VALIDATORS,
                                 default_types=default_types)


class PeopleHandler(requesthandlers.APIHandler):
    """Example handler with input schema validation that uses custom Validator.
    """
    @schema.validate(
        input_schema={
            "type": "object",
            "properties": {
                "name": {'type': "string"},
                "age": {'type': "int"},
            },
            'required': ['name', 'age'],
        },
コード例 #52
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_providing_neither_does_not_warn(self):
        Validator = validators.create(meta_schema={}, validators={})
        self.assertFalse(self.flushWarnings())

        Validator({})
        self.assertFalse(self.flushWarnings())
コード例 #53
0
ファイル: test_validators.py プロジェクト: w1r2p1/jsonschema
    def test_extending_a_legacy_validator_does_not_rewarn(self):
        Validator = validators.create(meta_schema={}, default_types={})
        self.assertTrue(self.flushWarnings())

        validators.extend(Validator)
        self.assertFalse(self.flushWarnings())
コード例 #54
0
ファイル: __init__.py プロジェクト: KenMercusLai/st2
CustomValidator = create(
    meta_schema=get_draft_schema(version='custom', additional_properties=True),
    validators={
        u"$ref": _validators.ref,
        u"additionalItems": _validators.additionalItems,
        u"additionalProperties": _validators.additionalProperties,
        u"allOf": _validators.allOf_draft4,
        u"anyOf": _validators.anyOf_draft4,
        u"dependencies": _validators.dependencies,
        u"enum": _validators.enum,
        u"format": _validators.format,
        u"items": _validators.items,
        u"maxItems": _validators.maxItems,
        u"maxLength": _validators.maxLength,
        u"maxProperties": _validators.maxProperties_draft4,
        u"maximum": _validators.maximum,
        u"minItems": _validators.minItems,
        u"minLength": _validators.minLength,
        u"minProperties": _validators.minProperties_draft4,
        u"minimum": _validators.minimum,
        u"multipleOf": _validators.multipleOf,
        u"not": _validators.not_draft4,
        u"oneOf": _validators.oneOf_draft4,
        u"pattern": _validators.pattern,
        u"patternProperties": _validators.patternProperties,
        u"properties": _validators.properties_draft3,
        u"type": _validators.type_draft4,
        u"uniqueItems": _validators.uniqueItems,
    },
    version="custom_validator",
)
コード例 #55
0
    ),
)


with warnings.catch_warnings():
    warnings.simplefilter("ignore", DeprecationWarning)

    TestDraft3LegacyTypeCheck = DRAFT3.to_unittest_testcase(
        # Interestingly the any part couldn't really be done w/the old API.
        (
            (test for test in each if test.schema != {"type": "any"})
            for each in DRAFT3.tests_of(name="type")
        ),
        name="TestDraft3LegacyTypeCheck",
        Validator=create(
            meta_schema=Draft3Validator.META_SCHEMA,
            validators=Draft3Validator.VALIDATORS,
            default_types=_DEPRECATED_DEFAULT_TYPES,
        ),
    )

    TestDraft4LegacyTypeCheck = DRAFT4.to_unittest_testcase(
        DRAFT4.tests_of(name="type"),
        name="TestDraft4LegacyTypeCheck",
        Validator=create(
            meta_schema=Draft4Validator.META_SCHEMA,
            validators=Draft4Validator.VALIDATORS,
            default_types=_DEPRECATED_DEFAULT_TYPES,
        ),
    )