def parse_single(input):
try:
result = load_yaml(input)
except YAMLError:
result = None
if not isinstance(result, dict):
# special parsing allowing lists without enclosing `{}`
try:
result = load_yaml("{" + input + "}")
except YAMLError as e:
raise_from(ConfigValueError,
"failed to parse `{}` as dict".format(input), e)
if not isinstance(result, dict):
raise ConfigValueError(type_error_msg("dict", result))
return result
def main(args=None):
args = command_handle_args(args, definition)
try:
# prepare arguments
filepath = os.path.abspath(os.path.expanduser(args.rules_file))
# parse rules file
with open(filepath, 'rb') as f:
data = to_str(f.read())
rules = load_yaml(data)
rules = expand_rules(rules)
verify_rules_dict(rules)
# compact rules
compacted = compact_rules(rules,
OSSupport().get_default_installer_names())
# output result
dump = dump_yaml(compacted)
if args.write:
with open(filepath, 'wb') as f:
f.write(to_bytes(dump))
else:
info(dump)
except (KeyboardInterrupt, EOFError):
sys.exit(1)
def from_command_line(self, value):
"""Create config value from value of command line parser.
A value of `UNSET_COMMAND_LINE` should be interpreted as
'unset'.
The default implementation parses the input string as yaml and
then invokes :meth:`from_yaml`.
Before returning a value, :meth:`verify` should be used to
verify the validity of the parsed value.
:param value: value from the command line parser, which is a
string when :meth:`command_line_multiple()` is false and a
list of strings otherwise, or `UNSET_COMMAND_LINE` if the
argument was omitted on the command line.
:raises ConfigValueError: if ``value`` cannot be parsed properly
or has invalid type or structure
"""
if value == UNSET_COMMAND_LINE:
return self.unset_value()
try:
return self.from_yaml(load_yaml(value))
except YAMLError as e:
raise_from(
ConfigValueError, "parsing command line value failed", e)
def load_config_file_yaml(path):
"""Utility for loading yaml config files.
Makes sure to always return a dict with strings as keys. Non-
existent or empty files result in an empty dictionary.
:raises ConfigValueError: if config file cannot be opened, decode or
parsed
"""
try:
if os.path.isfile(path):
with open(path, 'rb') as f:
binary_data = f.read()
config = load_yaml(to_str(binary_data))
else:
config = None
return process_config_file_yaml(config)
except EnvironmentError as e:
raise_from(ConfigValueError,
"failed to read config file `{}`".format(path), e)
except UnicodeError as e:
raise_from(ConfigValueError,
"failed to decode config file `{}`".format(path), e)
except YAMLError as e:
raise_from(ConfigValueError,
"failed to parse config file as YAML `{}`".format(path), e)
except ConfigValueError as e:
raise_from(ConfigValueError,
"config file has invalid structure `{}`".format(path), e)
def parse_source_descriptions(data, file_path='<string>'):
"""Parse a YAML string as source descriptions.
If parsing failes an error message is printed to console and an
empty list is returned.
:param str data: string containing YAML representation of source
descriptions
:param str file_path: name of the file whose contents ``data``
contains
:returns: tuple of ``file_path`` and parsed source descriptions
:rtype: `tuple(str, list)`
"""
try:
descriptions = load_yaml(data)
verify_source_description_list(descriptions)
except yaml.YAMLError as exc:
if hasattr(exc, 'problem_mark'):
mark = exc.problem_mark.line
col = exc.problem_mark.column
error("Invalid YAML in source list file '{0}' at '{1}:{2}':\n"
.format(file_path, mark + 1, col + 1) + to_str(exc))
else:
error("Invalid YAML in source list file '{0}':\n"
.format(file_path) + to_str(exc))
descriptions = []
return (file_path, descriptions)
def main(args=None):
args = command_handle_args(args, definition)
try:
# prepare arguments
filepath = os.path.abspath(os.path.expanduser(args.rules_file))
# parse rules file
with open(filepath, 'rb') as f:
data = to_str(f.read())
rules = load_yaml(data)
rules = expand_rules(rules)
verify_rules_dict(rules)
# compact rules
compacted = compact_rules(
rules, OSSupport().get_default_installer_names())
# output result
dump = dump_yaml(compacted)
if args.write:
with open(filepath, 'wb') as f:
f.write(to_bytes(dump))
else:
info(dump)
except (KeyboardInterrupt, EOFError):
sys.exit(1)
def load_data(self, arguments):
# TODO: Can we fast-fail if there is no connectivity (instead of
# doing the retries)? How to find out if there is no internet
# connection in general (as opposed to the resources not being
# accessible)?
data = load_url(arguments)
rules = load_yaml(data)
rules = expand_rules(rules)
return rules
def _parse_rules(rules_str):
rules = expand_rules(load_yaml(rules_str))
verify_rules_dict(rules)
return rules
from xylem.specs.plugins.rules import compact_rules
from xylem.yaml_utils import load_yaml
_default_installers = dict(ubuntu="apt", debian="apt")
test1 = load_yaml("""
foo:
ubuntu: libfoo
debian: libfoo
bar:
ubuntu:
lucid: libbar-1.2
maverick:
any_version: libbar
any_os:
pip: bar
baz:
any_os:
any_version:
pip: [baz]
ubuntu: [libbaz, libbaz-dev]
unicöde:
fedorä:
schröndinger’s:
füü:
[baß]
""")
expected1 = load_yaml("""
foo:
ubuntu:
any_version:
