Python Config.from_string方法代码示例

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_main_read_write_2files(tmpdir):
    fn_cfg1 = tmpdir.join("2files_cfg1.config").strpath
    fn_cfg2 = tmpdir.join("2files_cfg2.config").strpath
    fn_sch1 = tmpdir.join("2files_sch1.schema").strpath
    fn_sch2 = tmpdir.join("2files_sch2.schema").strpath

    cfg1 = Config.from_string("""\
a = 10
[c]
    c1 = 20
""")
    cfg2 = Config.from_string("""\
b = 1.5
[d]
    d1 = 2.5
""")

    sch1 = Schema.from_string("""\
a = Int()
[d]
    d1 = Float()
    d2 = Float(default=3.5)
""")
    sch2 = Schema.from_string("""\
b = Float()
[c]
    c1 = Int()
    c2 = Int(default=30)
""")

    cfg1.to_file(fn_cfg1)
    cfg2.to_file(fn_cfg2)
    sch1.to_file(fn_sch1)
    sch2.to_file(fn_sch2)

    args = ["read", "-i", fn_cfg1, "-i", fn_cfg2, "-s", fn_sch1, "-s", fn_sch2, "--defaults"]

    log_stream, out_stream = run(args)
    reference = """\
a = 10
[c]
    c1 = 20
    c2 = 30
b = 1.5
[d]
    d1 = 2.5
    d2 = 3.5

"""
    # print("=== reference:")
    # print(reference)
    # print("=== result:")
    # print(out_stream.getvalue())
    assert out_stream.getvalue() == reference
    assert log_stream.getvalue() == ""

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_module_config_on_configure_observer_run():
    cb0 = MyCallback(0, 0)
    cb1 = MyCallback(1, 1)
    assert cb0.ab == (0, 0)
    assert cb1.ab == (1, 1)
    module_config = ModuleConfig("""\
a = Int(default=2)
b = Int(default=5)
""",
        on_configure=[cb0, cb1])
    assert cb0.ab == (0, 0)
    assert cb1.ab == (1, 1)
    module_config.configure()
    assert cb0.ab == (2, 5)
    assert cb1.ab == (2, 5)
    cfg = Config.from_string("""\
a = 100
b = 3""")
    module_config.configure(cfg)
    assert cb0.ab == (100, 3)
    assert cb1.ab == (100, 3)
    cfg["a"] = 200
    module_config.configure(cfg)
    assert cb0.ab == (200, 3)
    assert cb1.ab == (200, 3)
    module_config.remove_on_configure_observer(cb1)
    cfg["a"] = 300
    module_config.configure(cfg)
    assert cb0.ab == (300, 3)
    assert cb1.ab == (200, 3)

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def config_protocol(protocol, config_de):
    ref_config_de_string = CONFIG_DE_STRING.get(protocol, None)
    if ref_config_de_string:
        config = Config.from_string(ref_config_de_string, protocol=protocol)
    else:
        config = config_de
    return config, protocol

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def config_fmt(fmt, config_de):
    ref_config_de_string = CONFIG_DE_STRING.get(fmt, None)
    if ref_config_de_string:
        config = Config.from_string(ref_config_de_string, fmt=fmt)
    else:
        config = config_de
    return config, fmt

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def mod_config0():
    return Config.from_string("""\
[mod0]
    opt0 = "abc"
[mod1]
    opt0 = 5.2
""", fmt="zirkon")

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_module_config_configure(module_config):
    assert not module_config.configured()
    config = Config.from_string("""\
opt0 = 4
""", fmt="zirkon")
    module_config.configure(config)
    assert module_config.configured()
    assert module_config['opt0'] == 4

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_Schema_default_section_subsection_option():
    schema = Schema.from_string("""\
[filesystems]
    [__default_section__]
        path = Str()
        [size]
            min_size_gb = Float(default=0.5)
            max_size_gb = Float(default=1.5)
        [files]
            __default_option__ = Str()
        [__default_section__]
            name = Str()
            __default_option__ = Int()
""")
    config = Config.from_string("""\
[filesystems]
    [home]
        path = "/home/user"
        [files]
            x = "x.txt"
            y = "y.txt"
            z = "y.txt"
        [a]
            name = "alpha"
            v0 = 10
            v1 = 20
            v2 = 30
        [b]
            name = "beta"
            v0 = 5
        [c]
            v0 = 1
            v1 = "g"
            v2 = 2
    [work]
        path = "/tmp/user"
        [size]
            min_size_gb = 0.0
""")
    validation = schema.validate(config)
    assert len(validation) == 1
    assert 'filesystems' in validation
    assert len(validation['filesystems']) == 1
    assert 'home' in validation['filesystems']
    assert len(validation['filesystems']['home']) == 1
    assert 'c' in validation['filesystems']['home']
    assert len(validation['filesystems']['home']['c']) == 2
    assert 'name' in validation['filesystems']['home']['c']
    assert 'v1' in validation['filesystems']['home']['c']

    assert validation
    assert config['filesystems']['home']['size']['min_size_gb'] == 0.5
    assert config['filesystems']['home']['size']['max_size_gb'] == 1.5
    assert 'a' in config['filesystems']['home']
    assert 'b' in config['filesystems']['home']
    assert 'c' in config['filesystems']['home']
    assert config['filesystems']['work']['size']['min_size_gb'] == 0.0
    assert config['filesystems']['work']['size']['max_size_gb'] == 1.5

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_Schema_PATH_defaults(macro_schema_PATH):
    filename = "/home/user/PATH.config"
    dirname, basename = os.path.split(filename)
    config = Config.from_string("""\
""", filename=filename, schema=macro_schema_PATH)
    assert config["a"] == os.path.join(dirname, "a_" + basename)
    assert config["b"] == filename + "b"
    assert config["sub"]["c"] == os.path.join(dirname, "c_" + basename)
    assert config["sub"]["d"] == filename + "d"

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_Schema_PATH_defaults_no_filename(macro_schema_PATH):
    dirname = os.getcwd()
    filename = ""
    print([dirname, filename])
    config = Config.from_string("""\
""", schema=macro_schema_PATH)
    assert config["a"] == os.path.join(dirname, "a_")
    assert config["b"] == filename + "b"
    assert config["sub"]["c"] == os.path.join(dirname, "c_")
    assert config["sub"]["d"] == filename + "d"

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_Schema_PATH_list(tmpdir, defaults):
    schema = Schema.from_string("""\
dirs = StrList(default=[PATH.cwd + PATH.sep + "xdir"])
files = StrList(default=[PATH.cwd + PATH.sep + "x.txt"])
""")
    config = Config.from_string("""\
dirs = ["xdir", PATH.cwd + PATH.sep + "ydir"]
""", schema=schema)
    assert config["dirs"] == ["xdir", os.path.abspath("ydir")]
    assert config["files"] == [os.path.abspath("x.txt")]

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_main_read_write_evaluate(tmpdir, evaluate, defaults):
    fn_cfg1 = tmpdir.join("evaluate_cfg1.config").strpath
    fn_sch1 = tmpdir.join("evaluate_sch1.schema").strpath

    cfg1 = Config.from_string("""\
a1 = 10
[b]
    b1 = ROOT['a1'] + 1
    b2 = PATH.filename + PATH.extsep + 'b2'
""", defaults=defaults)
    
    sch1 = Schema.from_string("""\
a1 = Int()
a2 = Int(default=SECTION['a1'] * 2)
[b]
    b1 = Int()
    b2 = Str()
    b3 = Str(default=PATH.dirname + PATH.sep + "b3")
""")

    cfg1.to_file(fn_cfg1)
    sch1.to_file(fn_sch1)

    args = ["read", "-i", fn_cfg1, "-s", fn_sch1, "--defaults"]
    if evaluate:
        args.append("-e")

    log_stream, out_stream = run(args)
    if evaluate:
        reference = """\
a1 = 10
[b]
    b1 = 11
    b2 = {b2!r}
    b3 = {b3!r}
a2 = 20

""".format(b2=fn_cfg1 + os.path.extsep + 'b2', b3=os.path.dirname(fn_cfg1) + os.path.sep + 'b3')
    else:
        reference = """\
a1 = 10
[b]
    b1 = ROOT['a1'] + 1
    b2 = PATH.filename + PATH.extsep + 'b2'
    b3 = PATH.dirname + PATH.sep + 'b3'
a2 = SECTION['a1'] * 2

"""
    print("=== evaluate={}".format(evaluate))
    print("=== reference:")
    print(reference)
    print("=== result:")
    print(out_stream.getvalue())
    assert out_stream.getvalue() == reference
    assert log_stream.getvalue() == ""

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def pack1_config0():
    return Config.from_string("""\
[pack1]
    alpha = False
    beta = 100
    [mod0]
        opt0 = "xyz"
        opt1 = 666
    [mod1]
        opt0 = 6.66
""", fmt="zirkon")

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_Schema_validation_order():
    schema = Schema.from_string("""\
__default_option__ = Str()
homedir = Str(default="/home/user")
""")
    config = Config.from_string("""\
workdir = SECTION["homedir"] + "/work"
""")

    validation = schema.validate(config)
    assert not validation
    assert config["homedir"] == "/home/user"
    assert config["workdir"] == "/home/user/work"

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_program_config_local_config(pack1_config0, merge):
    pack1 = __import__("pack1")
    reload(pack1)
    program_config = ProgramConfig()
    program_config.parse(pack1)
    assert pack1.get_beta() == 5
    assert pack1.mod0.get_opt0() == "abracadabra"
    assert pack1.mod0.get_opt1() == 10
    assert pack1.mod1.get_opt0() == 3.5
    program_config.configure(pack1_config0)
    pack1_config1 = pack1_config0.copy()
    assert pack1.get_beta() == 100
    assert pack1.mod0.get_opt0() == "xyz"
    assert pack1.mod0.get_opt1() == 666
    assert pack1.mod1.get_opt0() == 6.66
    # [pack1]
    #     alpha = False
    #     beta = 100
    #     [mod0]
    #         opt0 = "xyz"
    #         opt1 = 666
    #     [mod1]
    #         opt0 = 6.66
    pack1_config1 = Config.from_string("""\
[pack1]
    [mod0]
        opt0 = "1xyz"
        opt1 = 1666
    [mod1]
        opt0 = 16.66
""", fmt="zirkon")

    with program_config.local_config(pack1_config1, merge=merge) as (local_config, validation_result):
        assert isinstance(local_config, Config)
        assert isinstance(validation_result, Validation)
        assert not validation_result
        print("=== local_config:")
        local_config.dump()
        if merge:
            beta_value = 100
        else:
            beta_value = 5
        assert pack1.get_beta() == beta_value
        assert pack1.mod0.get_opt0() == "1xyz"
        assert pack1.mod0.get_opt1() == 1666
        assert pack1.mod1.get_opt0() == 16.66

    assert pack1.get_beta() == 100
    assert pack1.mod0.get_opt0() == "xyz"
    assert pack1.mod0.get_opt1() == 666
    assert pack1.mod1.get_opt0() == 6.66

# 需要导入模块: from zirkon.config import Config [as 别名]
# 或者: from zirkon.config.Config import from_string [as 别名]
def test_Schema_PATH_overridden(macro_schema_PATH):
    dirname = "/home/user"
    filename = os.path.join(dirname, "PATH.config")
    config = Config.from_string("""\
a = PATH.dirname + PATH.sep + "A"
b = PATH.filename + ".B"
[sub]
    c = PATH.dirname + PATH.sep + "C"
    d = PATH.filename + ".D"
""", filename=filename, schema=macro_schema_PATH)
    assert config["a"] == os.path.join(dirname, "A")
    assert config["b"] == filename + ".B"
    assert config["sub"]["c"] == os.path.join(dirname, "C")
    assert config["sub"]["d"] == filename + ".D"