def test_32_dump_and_load__w_options(self):
a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
a_path = os.path.join(self.workdir, "a.json")
b_path = os.path.join(self.workdir, "b.json")
A.dump(a, a_path, indent=2)
self.assertTrue(os.path.exists(a_path))
A.dump(b, b_path, indent=2)
self.assertTrue(os.path.exists(b_path))
a1 = A.load(a_path, parse_int=int)
self.assertEquals(a1["name"], a["name"])
self.assertEquals(a1["a"], a["a"])
self.assertEquals(a1["b"]["b"], a["b"]["b"])
self.assertEquals(a1["b"]["c"], a["b"]["c"])
a2 = A.load(os.path.join(self.workdir, '*.json'), parse_int=int)
self.assertEquals(a2["name"], a["name"])
self.assertEquals(a2["a"], b["a"])
self.assertEquals(a2["b"]["b"], [1, 2, 3, 4, 5])
self.assertEquals(a2["b"]["c"], a["b"]["c"])
self.assertEquals(a2["b"]["d"], b["b"]["d"])
a3 = A.load([a_path, b_path], parse_int=int)
self.assertEquals(a3["name"], a["name"])
self.assertEquals(a3["a"], b["a"])
self.assertEquals(a3["b"]["b"], [1, 2, 3, 4, 5])
self.assertEquals(a3["b"]["c"], a["b"]["c"])
self.assertEquals(a3["b"]["d"], b["b"]["d"])
def test_32_dump_and_load__w_options(self):
a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
a_path = os.path.join(self.workdir, "a.json")
b_path = os.path.join(self.workdir, "b.json")
TT.dump(a, a_path, indent=2)
self.assertTrue(os.path.exists(a_path))
TT.dump(b, b_path, indent=2)
self.assertTrue(os.path.exists(b_path))
a1 = TT.load(a_path, parse_int=int)
self.assertEquals(a1["name"], a["name"])
self.assertEquals(a1["a"], a["a"])
self.assertEquals(a1["b"]["b"], a["b"]["b"])
self.assertEquals(a1["b"]["c"], a["b"]["c"])
a2 = TT.load(os.path.join(self.workdir, '*.json'), parse_int=int)
self.assertEquals(a2["name"], a["name"])
self.assertEquals(a2["a"], b["a"])
self.assertEquals(a2["b"]["b"], [1, 2, 3, 4, 5])
self.assertEquals(a2["b"]["c"], a["b"]["c"])
self.assertEquals(a2["b"]["d"], b["b"]["d"])
a3 = TT.load([a_path, b_path], parse_int=int)
self.assertEquals(a3["name"], a["name"])
self.assertEquals(a3["a"], b["a"])
self.assertEquals(a3["b"]["b"], [1, 2, 3, 4, 5])
self.assertEquals(a3["b"]["c"], a["b"]["c"])
self.assertEquals(a3["b"]["d"], b["b"]["d"])
def test_30_dump_and_load(self):
a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
a_path = os.path.join(self.workdir, "a.json")
b_path = os.path.join(self.workdir, "b.json")
A.dump(a, a_path)
self.assertTrue(os.path.exists(a_path))
A.dump(b, b_path)
self.assertTrue(os.path.exists(b_path))
a1 = A.load(a_path)
self.assertEquals(a1["name"], a["name"])
self.assertEquals(a1["a"], a["a"])
self.assertEquals(a1["b"]["b"], a["b"]["b"])
self.assertEquals(a1["b"]["c"], a["b"]["c"])
a2 = A.load(os.path.join(self.workdir, '*.json'))
self.assertEquals(a2["name"], a["name"])
self.assertEquals(a2["a"], b["a"])
self.assertEquals(a2["b"]["b"], [1, 2, 3, 4, 5])
self.assertEquals(a2["b"]["c"], a["b"]["c"])
self.assertEquals(a2["b"]["d"], b["b"]["d"])
a3 = A.load([a_path, b_path])
self.assertEquals(a3["name"], a["name"])
self.assertEquals(a3["a"], b["a"])
self.assertEquals(a3["b"]["b"], [1, 2, 3, 4, 5])
self.assertEquals(a3["b"]["c"], a["b"]["c"])
self.assertEquals(a3["b"]["d"], b["b"]["d"])
def test_30_dump_and_load(self):
a = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
b = dict(a=2, b=dict(b=[1, 2, 3, 4, 5], d="D"))
a_path = os.path.join(self.workdir, "a.json")
b_path = os.path.join(self.workdir, "b.json")
TT.dump(a, a_path)
self.assertTrue(os.path.exists(a_path))
TT.dump(b, b_path)
self.assertTrue(os.path.exists(b_path))
a1 = TT.load(a_path)
self.assertEqual(a1["name"], a["name"])
self.assertEqual(a1["a"], a["a"])
self.assertEqual(a1["b"]["b"], a["b"]["b"])
self.assertEqual(a1["b"]["c"], a["b"]["c"])
a2 = TT.load(os.path.join(self.workdir, '*.json'))
self.assertEqual(a2["name"], a["name"])
self.assertEqual(a2["a"], b["a"])
self.assertEqual(a2["b"]["b"], [1, 2, 3, 4, 5])
self.assertEqual(a2["b"]["c"], a["b"]["c"])
self.assertEqual(a2["b"]["d"], b["b"]["d"])
a3 = TT.load([a_path, b_path])
self.assertEqual(a3["name"], a["name"])
self.assertEqual(a3["a"], b["a"])
self.assertEqual(a3["b"]["b"], [1, 2, 3, 4, 5])
self.assertEqual(a3["b"]["c"], a["b"]["c"])
self.assertEqual(a3["b"]["d"], b["b"]["d"])
def test_30_dump_and_load(self):
TT.dump(self.dic, self.a_path)
TT.dump(self.upd, self.b_path)
self.assertTrue(os.path.exists(self.a_path))
self.assertTrue(os.path.exists(self.b_path))
res = TT.load(self.a_path)
self.assert_dicts_equal(res, self.dic)
res = TT.load(self.g_path)
self.assert_dicts_equal(res, self.exp)
res = TT.load([self.a_path, self.b_path])
self.assert_dicts_equal(res, self.exp)
def test_30_dump_and_load(self):
TT.dump(self.dic, self.a_path)
TT.dump(self.upd, self.b_path)
self.assertTrue(self.a_path.exists())
self.assertTrue(self.b_path.exists())
res = TT.load(self.a_path)
self.assert_dicts_equal(res, self.dic)
res = TT.load(self.g_path)
self.assert_dicts_equal(res, self.exp)
res = TT.load([self.a_path, self.b_path])
self.assert_dicts_equal(res, self.exp)
def test_34_load__ignore_missing(self):
null_cntnr = TT.to_container()
cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
assert not os.path.exists(cpath)
self.assertEqual(
TT.load([cpath], ac_parser="ini", ignore_missing=True), null_cntnr)
def test_34_load__ignore_missing(self):
cpath = pathlib.Path(os.curdir) / "conf_file_should_not_exist"
assert not cpath.exists()
self.assertEqual(TT.load([cpath], ac_parser="ini",
ignore_missing=True),
NULL_CNTNR)
def main(argv=sys.argv):
p = option_parser()
(options, args) = p.parse_args(argv[1:])
llvl = logging.DEBUG if options.debug else logging.INFO
logging.basicConfig(level=llvl)
if not args:
if options.list:
sys.stdout.write(
"Supported config types: " + ", ".join(A.list_types()) + "\n"
)
sys.exit(0)
else:
p.print_usage()
sys.exit(-1)
data = A.load(args, options.itype, options.merge)
if options.args:
diff = A.loads(options.args, options.atype)
data.update(diff, options.merge)
if options.output:
cp = A.find_loader(options.output, options.otype)
cp.dump(data, options.output)
else:
assert options.otype is not None, \
"Please specify Output type w/ -O/--otype option"
cp = A.find_loader(None, options.otype)
sys.stdout.write(cp.dumps(data))
def main(argv=None):
"""
:param argv: Argument list to parse or None (sys.argv will be set).
"""
(parser, options, args) = parse_args(argv=argv)
API.LOGGER.setLevel(to_log_level(options.loglevel))
_check_options_and_args(parser, options, args)
cnf = API.to_container(os.environ.copy() if options.env else {})
diff = API.load(args, options.itype,
ignore_missing=options.ignore_missing,
ac_merge=options.merge, ac_template=options.template,
ac_schema=options.schema)
_exit_if_load_failure(diff, "Failed to load: args=%s" % ", ".join(args))
cnf.update(diff)
if options.args:
diff = anyconfig.parser.parse(options.args)
cnf.update(diff)
_exit_if_only_to_validate(options.validate)
if options.gen_schema:
cnf = API.gen_schema(cnf)
if options.get:
cnf = _do_get(cnf, options.get)
if options.set:
(key, val) = options.set.split('=')
API.set_(cnf, key, anyconfig.parser.parse(val))
_output_result(cnf, options.output, options.otype, args[0], options.itype)
def test_34_load__ignore_missing(self):
cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
assert not os.path.exists(cpath)
self.assertEqual(TT.load([cpath], ac_parser="ini",
ignore_missing=True),
NULL_CNTNR)
def test_34_load__ignore_missing(self):
cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
assert not os.path.exists(cpath)
self.assertEqual(TT.load([cpath], ac_parser="ini",
ignore_missing=True),
NULL_CNTNR)
def test_34_load__ignore_missing(self):
null_cntnr = TT.to_container()
cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
assert not os.path.exists(cpath)
self.assertEqual(TT.load([cpath], ac_parser="ini",
ignore_missing=True),
null_cntnr)
def test_34_load__ignore_missing(self):
null_cntnr = A.container()
cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
assert not os.path.exists(cpath)
self.assertEquals(A.load([cpath], forced_type="ini",
ignore_missing=True),
null_cntnr)
def test_34_load__ignore_missing(self):
null_cntnr = A.container()
cpath = os.path.join(os.curdir, "conf_file_should_not_exist")
assert not os.path.exists(cpath)
self.assertEquals(
A.load([cpath], forced_type="ini", ignore_missing=True),
null_cntnr)
def test_31_dump_and_load__to_from_stream(self):
with TT.open(self.a_path, mode='w') as strm:
TT.dump(self.dic, strm)
self.assertTrue(os.path.exists(self.a_path))
with TT.open(self.a_path) as strm:
res = TT.load(strm, ac_parser="json")
self.assert_dicts_equal(res, self.dic)
def test_31_dump_and_load__to_from_stream(self):
with TT.open(self.a_path, mode='w') as strm:
TT.dump(self.dic, strm)
self.assertTrue(self.a_path.exists())
with TT.open(self.a_path) as strm:
res = TT.load(strm, ac_parser="json")
self.assert_dicts_equal(res, self.dic)
def test_32_dump_and_load__w_options(self):
TT.dump(self.dic, self.a_path, indent=2)
self.assertTrue(os.path.exists(self.a_path))
TT.dump(self.upd, self.b_path, indent=2)
self.assertTrue(os.path.exists(self.b_path))
res = TT.load(self.a_path, parse_int=int)
dic = copy.deepcopy(self.dic)
self.assert_dicts_equal(res, dic)
res = TT.load(self.g_path, parse_int=int)
exp = copy.deepcopy(self.exp)
self.assert_dicts_equal(res, exp)
res = TT.load([self.a_path, self.b_path], parse_int=int)
exp = copy.deepcopy(self.exp)
self.assert_dicts_equal(res, exp)
def test_32_dump_and_load__w_options(self):
TT.dump(self.dic, self.a_path, indent=2)
self.assertTrue(self.a_path.exists())
TT.dump(self.upd, self.b_path, indent=2)
self.assertTrue(self.b_path.exists())
res = TT.load(self.a_path, parse_int=int)
dic = copy.deepcopy(self.dic)
self.assert_dicts_equal(res, dic)
res = TT.load(self.g_path, parse_int=int)
exp = copy.deepcopy(self.exp)
self.assert_dicts_equal(res, exp)
res = TT.load([self.a_path, self.b_path], parse_int=int)
exp = copy.deepcopy(self.exp)
self.assert_dicts_equal(res, exp)
def main(argv=sys.argv):
"""
:param argv: Argument list to parse [sys.argv]
"""
parser = option_parser()
(options, args) = parser.parse_args(argv[1:])
A.set_loglevel(to_log_level(options.loglevel))
if not args:
if options.list:
tlist = ", ".join(A.list_types()) + "\n"
sys.stdout.write("Supported config types: " + tlist)
sys.exit(0)
else:
parser.print_usage()
sys.exit(-1)
data = data = os.environ.copy() if options.env else A.container()
diff = A.load(args, options.itype, ignore_missing=options.ignore_missing,
merge=options.merge, ac_template=options.template)
data.update(diff)
if options.args:
diff = A.loads(options.args, options.atype,
ac_template=options.template, ac_context=data)
data.update(diff, options.merge)
if options.get:
(data, err) = A.get(data, options.get)
if err:
raise RuntimeError(err)
if options.set:
A.set_(data, *(options.set.split('=')))
if options.output:
cparser = A.find_loader(options.output, options.otype)
if cparser is None:
raise RuntimeError("No suitable dumper was found for %s",
options.output)
cparser.dump(data, options.output)
else:
# TODO: Reuse input type automatically detected as it's impossible to
# detect output type w/o options.output.
if options.otype is None:
if options.itype is None:
raise RuntimeError("Please specify input and/or output type "
"with -I (--itype) or -O (--otype) option")
else:
options.otype = options.itype
cparser = A.find_loader(None, options.otype)
sys.stdout.write(cparser.dumps(data))
def test_38_load_w_validation_yaml(self):
cnf_path = os.path.join(self.workdir, "cnf.yml")
scm_path = os.path.join(self.workdir, "scm.yml")
TT.dump(CNF_0, cnf_path)
TT.dump(SCM_0, scm_path)
cnf_2 = TT.load(cnf_path, ac_context={}, ac_schema=scm_path)
self.assertEqual(cnf_2["name"], CNF_0["name"])
self.assertEqual(cnf_2["a"], CNF_0["a"])
self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])
def test_36_load_w_validation(self):
cnf_path = os.path.join(self.workdir, "cnf.json")
scm_path = os.path.join(self.workdir, "scm.json")
TT.dump(CNF_0, cnf_path)
TT.dump(SCM_0, scm_path)
cnf_2 = TT.load(cnf_path, ac_context={}, ac_schema=scm_path)
self.assertEqual(cnf_2["name"], CNF_0["name"])
self.assertEqual(cnf_2["a"], CNF_0["a"])
self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])
def test_38_load_w_validation_yaml(self):
cnf_path = self.workdir / "cnf.yml"
scm_path = self.workdir / "scm.yml"
TT.dump(CNF_0, cnf_path)
TT.dump(SCM_0, scm_path)
cnf_2 = TT.load(cnf_path, ac_context={}, ac_schema=scm_path)
self.assertEqual(cnf_2["name"], CNF_0["name"])
self.assertEqual(cnf_2["a"], CNF_0["a"])
self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])
def test_90_no_inputs__w_env_option(self):
infile = "/dev/null"
output = os.path.join(self.workdir, "out.yml")
if A.find_loader(infile, "yaml") is None:
return
TT.main(["dummy", "--env", "-o", output, infile])
data = A.load(output)
for env_var, env_val in os.environ.items():
self.assertTrue(env_var in data)
self.assertEquals(env_val, os.environ[env_var])
def test_32_single_input_w_get_option(self):
d = dict(name="a", a=dict(b=dict(c=[1, 2], d="C")))
input = os.path.join(self.workdir, "a.json")
output = os.path.join(self.workdir, "b.json")
A.dump(d, input)
self.assertTrue(os.path.exists(input))
T.main(["dummy", "-o", output, "--get", "a.b", input])
self.assertTrue(os.path.exists(output))
x = A.load(output)
self.assertEquals(x, d['a']['b'])
def test_31_dump_and_load__to_from_stream(self):
cnf = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
cpath = os.path.join(self.workdir, "a.json")
with open(cpath, 'w') as strm:
TT.dump(cnf, strm)
self.assertTrue(os.path.exists(cpath))
with open(cpath, 'r') as strm:
cnf1 = TT.load(strm, ac_parser="json")
self.assertTrue(dicts_equal(cnf, cnf1),
"cnf vs. cnf1: %s\n\n%s" % (str(cnf), str(cnf1)))
def main(argv=sys.argv):
"""
:param argv: Argument list to parse [sys.argv]
"""
parser = option_parser()
(options, args) = parser.parse_args(argv[1:])
A.set_loglevel(to_log_level(options.loglevel))
if not args:
if options.list:
tlist = ", ".join(A.list_types()) + "\n"
sys.stdout.write("Supported config types: " + tlist)
sys.exit(0)
else:
parser.print_usage()
sys.exit(-1)
data = A.load(args,
options.itype,
options.merge,
ignore_missing=options.ignore_missing)
if options.args:
diff = A.loads(options.args, options.atype)
data.update(diff, options.merge)
if options.get:
(data, err) = A.get(data, options.get)
if err:
raise RuntimeError(err)
if options.set:
A.set_(data, *(options.set.split('=')))
if options.output:
cparser = A.find_loader(options.output, options.otype)
cparser.dump(data, options.output)
else:
# TODO: Reuse input type automatically detected as it's impossible to
# detect output type w/o options.output.
if options.otype is None:
if options.itype is None:
raise RuntimeError("Please specify input and/or output type "
"with -I (--itype) or -O (--otype) option")
else:
options.otype = options.itype
cparser = A.find_loader(None, options.otype)
sys.stdout.write(cparser.dumps(data))
def test_31_dump_and_load__to_from_stream(self):
cnf = dict(a=1, b=dict(b=[0, 1], c="C"), name="a")
cpath = os.path.join(self.workdir, "a.json")
with open(cpath, 'w') as strm:
TT.dump(cnf, strm)
self.assertTrue(os.path.exists(cpath))
with open(cpath, 'r') as strm:
cnf1 = TT.load(strm, ac_parser="json")
self.assertTrue(dicts_equal(cnf, cnf1),
"cnf vs. cnf1: %s\n\n%s" % (str(cnf), str(cnf1)))
def test_32_single_input_w_get_option(self):
d = dict(name="a", a=dict(b=dict(c=[1, 2], d="C")))
input = os.path.join(self.workdir, "a.json")
output = os.path.join(self.workdir, "b.json")
A.dump(d, input)
self.assertTrue(os.path.exists(input))
T.main(["dummy", "-o", output, "--get", "a.b", input])
self.assertTrue(os.path.exists(output))
x = A.load(output)
self.assertEquals(x, d['a']['b'])
def parse_and_load_contexts(contexts, werr=False, enc=jinja2_cli.compat.ENCODING):
"""
:param contexts: list of context file specs
:param werr: Exit immediately if True and any errors occurrs
while loading context files
:param enc: Input encoding of context files (dummy param)
"""
ctx = container()
if contexts:
for fpath, ftype in concat(parse_filespec(f) for f in contexts):
diff = load(fpath, ftype)
ctx.update(diff)
return ctx
def test_38_load_w_validation_yaml(self):
if "yml" not in TT.list_types():
skip_test()
cnf_path = os.path.join(self.workdir, "cnf.yml")
scm_path = os.path.join(self.workdir, "scm.yml")
TT.dump(CNF_0, cnf_path)
TT.dump(SCM_0, scm_path)
cnf_2 = TT.load(cnf_path, ac_context={}, ac_schema=scm_path)
self.assertEqual(cnf_2["name"], CNF_0["name"])
self.assertEqual(cnf_2["a"], CNF_0["a"])
self.assertEqual(cnf_2["b"]["b"], CNF_0["b"]["b"])
self.assertEqual(cnf_2["b"]["c"], CNF_0["b"]["c"])
def test_34_single_input_w_set_option(self):
d = dict(name="a", a=dict(b=dict(c=[1, 2], d="C")))
input = os.path.join(self.workdir, "a.json")
output = os.path.join(self.workdir, "b.json")
A.dump(d, input)
self.assertTrue(os.path.exists(input))
T.main(["dummy", "-o", output, "--set", "a.b.d=E", input])
self.assertTrue(os.path.exists(output))
ref = d.copy()
ref['a']['b']['d'] = 'E'
x = A.load(output)
self.assertEquals(x, ref)
def test_34_single_input_w_set_option(self):
d = dict(name="a", a=dict(b=dict(c=[1, 2], d="C")))
input = os.path.join(self.workdir, "a.json")
output = os.path.join(self.workdir, "b.json")
A.dump(d, input)
self.assertTrue(os.path.exists(input))
T.main(["dummy", "-o", output, "--set", "a.b.d=E", input])
self.assertTrue(os.path.exists(output))
ref = d.copy()
ref['a']['b']['d'] = 'E'
x = A.load(output)
self.assertEquals(x, ref)
def _load_diff(args, options):
"""
:param args: Extra argument list
:param options: :class:`optparse.Values` object
"""
try:
diff = API.load(args, options.itype,
ignore_missing=options.ignore_missing,
ac_merge=options.merge,
ac_template=options.template,
ac_schema=options.schema)
except API.UnknownParserTypeError:
_exit_with_output("Wrong input type '%s'" % options.itype, 1)
except API.UnknownFileTypeError:
_exit_with_output("No appropriate backend was found for given file "
"'%s'" % options.itype, 1)
_exit_if_load_failure(diff, "Failed to load: args=%s" % ", ".join(args))
return diff
def _load_diff(args):
"""
:param args: :class:`~argparse.Namespace` object
"""
try:
diff = API.load(args.inputs, args.itype,
ac_ignore_missing=args.ignore_missing,
ac_merge=args.merge,
ac_template=args.template,
ac_schema=args.schema)
except API.UnknownProcessorTypeError:
_exit_with_output("Wrong input type '%s'" % args.itype, 1)
except API.UnknownFileTypeError:
_exit_with_output("No appropriate backend was found for given file "
"'%s'" % args.itype, 1)
_exit_if_load_failure(diff,
"Failed to load: args=%s" % ", ".join(args.inputs))
return diff
def test_40_load_w_query(self):
cnf_path = self.workdir / "cnf.json"
TT.dump(CNF_0, cnf_path)
try:
if TT.query.jmespath:
self.assertEqual(TT.load(cnf_path, ac_query="a"), 1)
self.assertEqual(TT.load(cnf_path, ac_query="b.b"), [1, 2])
self.assertEqual(TT.load(cnf_path, ac_query="b.b[1]"), 2)
self.assertEqual(TT.load(cnf_path, ac_query="b.b[1:]"), [2])
self.assertEqual(TT.load(cnf_path, ac_query="b.b[::-1]"),
[2, 1])
self.assertEqual(TT.load(cnf_path, ac_query="length(b.b)"), 2)
except (NameError, AttributeError):
pass # jmespath is not available.
def test_40_load_w_query(self):
cnf_path = os.path.join(self.workdir, "cnf.json")
TT.dump(CNF_0, cnf_path)
try:
if TT.query.jmespath:
self.assertEqual(TT.load(cnf_path, ac_query="a"), 1)
self.assertEqual(TT.load(cnf_path, ac_query="b.b"), [1, 2])
self.assertEqual(TT.load(cnf_path, ac_query="b.b[1]"), 2)
self.assertEqual(TT.load(cnf_path, ac_query="b.b[1:]"), [2])
self.assertEqual(TT.load(cnf_path, ac_query="b.b[::-1]"),
[2, 1])
self.assertEqual(TT.load(cnf_path, ac_query="length(b.b)"), 2)
except (NameError, AttributeError):
pass # jmespath is not available.
def _load_diff(args, extra_opts):
"""
:param args: :class:`argparse.Namespace` object
:param extra_opts: Map object given to API.load as extra options
"""
try:
diff = API.load(args.inputs, args.itype,
ac_ignore_missing=args.ignore_missing,
ac_merge=args.merge,
ac_template=args.template,
ac_schema=args.schema,
**extra_opts)
except API.UnknownProcessorTypeError:
_exit_with_output("Wrong input type '%s'" % args.itype, 1)
except API.UnknownFileTypeError:
_exit_with_output("No appropriate backend was found for given file "
"'%s'" % args.itype, 1)
_exit_if_load_failure(diff,
"Failed to load: args=%s" % ", ".join(args.inputs))
return diff
def test_50_single_input__w_arg_option(self):
a = dict(name="a", a=1, b=dict(b=[1, 2], c="C"), d=[1, 2])
input = os.path.join(self.workdir, "a.json")
output = os.path.join(self.workdir, "b.json")
A.dump(a, input)
self.assertTrue(os.path.exists(input))
T.main(["dummy", "-o", output, "-A", "a:10;name:x;d:3,4", input])
self.assertTrue(os.path.exists(output))
x = A.load(output)
self.assertNotEquals(a["name"], x["name"])
self.assertNotEquals(a["a"], x["a"])
self.assertNotEquals(a["d"], x["d"])
self.assertEquals(x["name"], 'x')
self.assertEquals(x["a"], 10)
self.assertEquals(x["d"], [3, 4])
def parse_and_load_contexts(contexts, schema=None, werr=False):
"""
:param contexts: list of context file specs
:param schema: JSON schema file in any formats anyconfig supports, to
validate given context files
:param werr: Exit immediately if True and any errors occurrs
while loading context files
"""
ctx = Container()
diff = None
if contexts:
for fpath, ftype in concat(parse_filespec(f) for f in contexts):
try:
diff = load(fpath, ac_parser=ftype, ac_schema=schema)
if diff is not None:
ctx.update(diff)
except (IOError, OSError, AttributeError):
if werr:
raise
return ctx
def test_50_single_input__w_arg_option(self):
a = dict(name="a", a=1, b=dict(b=[1, 2], c="C"), d=[1, 2])
input = os.path.join(self.workdir, "a.json")
output = os.path.join(self.workdir, "b.json")
A.dump(a, input)
self.assertTrue(os.path.exists(input))
T.main(["dummy", "-o", output, "-A", "a:10;name:x;d:3,4", input])
self.assertTrue(os.path.exists(output))
x = A.load(output)
self.assertNotEquals(a["name"], x["name"])
self.assertNotEquals(a["a"], x["a"])
self.assertNotEquals(a["d"], x["d"])
self.assertEquals(x["name"], 'x')
self.assertEquals(x["a"], 10)
self.assertEquals(x["d"], [3, 4])
def main(argv=None):
"""
:param argv: Argument list to parse or None (sys.argv will be set).
"""
(parser, options, args) = parse_args(argv=argv)
API.LOGGER.setLevel(to_log_level(options.loglevel))
_check_options_and_args(parser, options, args)
cnf = API.to_container(os.environ.copy() if options.env else {})
diff = API.load(args,
options.itype,
ignore_missing=options.ignore_missing,
ac_merge=options.merge,
ac_template=options.template,
ac_schema=options.schema)
_exit_if_load_failure(diff, "Failed to load: args=%s" % ", ".join(args))
cnf.update(diff)
if options.args:
diff = anyconfig.parser.parse(options.args)
cnf.update(diff)
_exit_if_only_to_validate(options.validate)
if options.gen_schema:
cnf = API.gen_schema(cnf)
if options.get:
cnf = _do_get(cnf, options.get)
if options.set:
(key, val) = options.set.split('=')
API.set_(cnf, key, anyconfig.parser.parse(val))
_output_result(cnf, options.output, options.otype, args[0], options.itype)
def main(argv=None):
"""
:param argv: Argument list to parse or None (sys.argv will be set).
"""
if argv is None:
argv = sys.argv
parser = option_parser()
(options, args) = parser.parse_args(argv[1:])
A.set_loglevel(to_log_level(options.loglevel))
if not args:
if options.list:
tlist = ", ".join(A.list_types()) + "\n"
sys.stdout.write("Supported config types: " + tlist)
sys.exit(0)
else:
parser.print_usage()
sys.exit(1)
if options.validate and options.schema is None:
sys.stderr.write("--validate option requires --scheme option")
sys.exit(1)
data = data = os.environ.copy() if options.env else A.container()
diff = A.load(args, options.itype,
ignore_missing=options.ignore_missing,
merge=options.merge, ac_template=options.template,
ac_schema=options.schema)
if diff is None:
sys.stderr.write("Validation failed")
sys.exit(1)
data.update(diff)
if options.args:
diff = A.loads(options.args, options.atype,
ac_template=options.template, ac_context=data)
data.update(diff, options.merge)
if options.validate:
A.LOGGER.info("Validation succeeds")
sys.exit(0)
if options.gen_schema:
data = A.gen_schema(data)
if options.get:
(data, err) = A.get(data, options.get)
if err:
raise RuntimeError(err)
# Output primitive types as it is.
if not anyconfig.mergeabledict.is_mergeabledict_or_dict(data):
sys.stdout.write(str(data) + '\n')
return
if options.set:
(key, val) = options.set.split('=')
A.set_(data, key, anyconfig.parser.parse(val))
if options.output:
cparser = A.find_loader(options.output, options.otype)
if cparser is None:
raise RuntimeError("No suitable dumper was found for %s",
options.output)
cparser.dump(data, options.output)
else:
if options.otype is None:
if options.itype is None:
psr = A.find_loader(args[0])
if psr is not None:
options.otype = psr.type() # Reuse detected input type
else:
raise RuntimeError("Please specify input and/or output "
"type with -I (--itype) or -O "
"(--otype) option")
else:
options.otype = options.itype
cparser = A.find_loader(None, options.otype)
sys.stdout.write(cparser.dumps(data) + '\n')