Python core.Core方法代码示例

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def validate_domain_yaml(cls, yaml):
        """Validate domain yaml."""
        from pykwalify.core import Core

        log = logging.getLogger('pykwalify')
        log.setLevel(logging.WARN)

        schema_file = pkg_resources.resource_filename(__name__,
                                                      "schemas/domain.yml")
        source_data = utils.read_yaml_string(yaml)
        c = Core(source_data=source_data,
                 schema_files=[schema_file])
        try:
            c.validate(raise_exception=True)
        except SchemaError:
            raise InvalidDomain("Failed to validate your domain yaml. "
                                "Make sure the file is correct, to do so"
                                "take a look at the errors logged during "
                                "validation previous to this exception. ") 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def ext_ostree(value, rule_obj, path):
    if type(value) is str:
        if value != "latest":
            raise SchemaError("expected string 'latest'")
    elif type(value) is dict:
        schema = {'mapping':
                  {'remote': {'type': 'str'},
                   'branch': {'type': 'str'},
                   'revision': {'type': 'str'}
                   }
                  }
        c = Core(source_data=value, schema_data=schema)
        c.validate()
    else:
        raise SchemaError("expected str or map")
    return True 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def validate(f):
    logger.info('Validating {}'.format(f.name))
    c = Core(
        source_file=f.name,
        schema_files=[asset_helpers.resolve_from_site_packages('schema.yaml')],
        extensions=[asset_helpers.resolve_from_site_packages('puppet_schema_extensions.py')]
    )
    c.validate(raise_exception=True)
    click.echo("Finished validating: {}".format(f.name))
    click.echo("Finished validating: OK") 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def validate_config_format(config_file, config_schema):
        schema = os.path.abspath(config_schema)
        c = PyKwalify(source_file=config_file, schema_files=[schema])
        c.validate(raise_exception=True) 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def __init__(self, config_path, schema_path, config_changes):
        with open(config_path, 'rt') as src:
            config = read_config(src)
        make_config_changes(config, config_changes)

        self.multi_stage = 'stages' in config
        if self.multi_stage:
            stages = [(k, v) for k, v in config['stages'].items() if v]
            ordered_changes = OrderedDict(
                sorted(stages, key=lambda (k, v): v['number'],))
            self.ordered_stages = OrderedDict()
            for name, changes in ordered_changes.items():
                current_config = copy.deepcopy(config)
                del current_config['stages']
                del changes['number']
                merge_recursively(current_config, changes)
                self.ordered_stages[name] = current_config

        # Validate the configuration and the training stages
        if schema_path:
            with open(os.path.expandvars(schema_path)) as schema_file:
                schema = yaml.safe_load(schema_file)
                core = Core(source_data=config, schema_data=schema)
                core.validate(raise_exception=True)
                if self.multi_stage:
                    for stage in self.ordered_stages.values():
                        core = Core(source_data=stage, schema_data=schema)
                        core.validate(raise_exception=True)
        super(Configuration, self).__init__(config) 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def _validate_yaml(schema, config):
    """Raises exception if config is invalid.

    :param schema: The schema to validate with (browbeat, rally...)
    :param config: Loaded yaml to validate
    """
    check = pykwalify_core.Core(
        source_data=config, schema_files=["{}/{}.yml".format(conf_schema_path, schema)])
    try:
        check.validate(raise_exception=True)
    except pykwalify_errors.SchemaError as e:
        _logger.error("Schema validation failed")
        raise Exception("File does not conform to {} schema: {}".format(schema, e)) 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def validate(p):
    for portfolio_file_name in os.listdir(p):
        portfolios_file_path = os.path.sep.join([p, portfolio_file_name])
        logger.info('Validating {}'.format(portfolios_file_path))
        core = Core(
            source_file=portfolios_file_path,
            schema_files=[resolve_from_site_packages('schema.yaml')]
        )
        core.validate(raise_exception=True)
        click.echo("Finished validating: {}".format(portfolios_file_path))
    click.echo("Finished validating: OK") 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def verify_generic(to_verify, schema):
    """Verify a generic file against a given schema

    Args:
        to_verify (dict): Filename of source tests to check
        schema (dict): Schema to verify against

    Raises:
        BadSchemaError: Schema did not match
    """
    logger.debug("Verifying %s against %s", to_verify, schema)

    here = os.path.dirname(os.path.abspath(__file__))
    extension_module_filename = os.path.join(here, "extensions.py")

    verifier = core.Core(
        source_data=to_verify,
        schema_data=schema,
        extensions=[extension_module_filename],
    )

    try:
        verifier.validate()
    except pykwalify.errors.PyKwalifyException as e:
        logger.exception("Error validating %s", to_verify)
        raise BadSchemaError() from e 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def ext_build(value, rule_obj, path):
    if type(value) not in [dict, bool]:
        raise SchemaError("expected bool or map")
    if type(value) is dict:
        schema = {'mapping':
                  {'config-opts': {'type': 'str'},
                   'build-opts': {'type': 'str'},
                   'install-opts': {'type': 'str'}
                   }
                  }
        c = Core(source_data=value, schema_data=schema)
        c.validate()
    return True 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def validate_yaml(config, _logger):
    _logger.info("Validating the configuration file passed by the user")
    stream = open("lib/validate.yaml", 'r')
    schema = yaml.load(stream)
    check = pykwalify_core.Core(source_data=config, schema_data=schema)
    try:
        check.validate(raise_exception=True)
        _logger.info("Validation successful")
    except pykwalify_errors.SchemaError as e:
        _logger.error("Schema Validation failed")
        raise Exception('File does not conform to schema: {}'.format(e)) 

# 需要导入模块: from pykwalify import core [as 别名]
# 或者: from pykwalify.core import Core [as 别名]
def validate_yaml_schema(
    yaml_file_content: Text, schema_path: Text, show_validation_errors: bool = True
) -> None:
    """
    Validate yaml content.

    Args:
        yaml_file_content: the content of the yaml file to be validated
        schema_path: the schema of the yaml file
        show_validation_errors: if true, validation errors are shown
    """
    from pykwalify.core import Core
    from pykwalify.errors import SchemaError
    from ruamel.yaml import YAMLError
    import pkg_resources
    import rasa.utils.io
    import logging

    log = logging.getLogger("pykwalify")
    if show_validation_errors:
        log.setLevel(logging.WARN)
    else:
        log.setLevel(logging.CRITICAL)

    try:
        source_data = rasa.utils.io.read_yaml(yaml_file_content)
    except YAMLError:
        raise InvalidYamlFileError(
            "The provided yaml file is invalid. You can use "
            "http://www.yamllint.com/ to validate the yaml syntax "
            "of your file."
        )
    except DuplicateKeyError as e:
        raise InvalidYamlFileError(
            "The provided yaml file contains a duplicated key: '{}'. You can use "
            "http://www.yamllint.com/ to validate the yaml syntax "
            "of your file.".format(str(e))
        )

    try:
        schema_file = pkg_resources.resource_filename(PACKAGE_NAME, schema_path)

        c = Core(source_data=source_data, schema_files=[schema_file])
        c.validate(raise_exception=True)
    except SchemaError:
        raise InvalidYamlFileError(
            "Failed to validate yaml file. "
            "Please make sure the file is correct and all "
            "mandatory parameters are specified; to do so, "
            "take a look at the errors logged during "
            "validation previous to this exception."
        )