def test_resolve_str_interpolation(query: str, result: Any) -> None:
cfg = OmegaConf.create({"foo": 10, "bar": "${foo}"})
assert (cfg._resolve_interpolation(
key=None,
value=StringNode(value=query),
throw_on_missing=False,
throw_on_resolution_failure=True,
) == result)
read_write,
)
from omegaconf.errors import ConfigAttributeError, ConfigKeyError
from . import Color, StructuredWithMissing, User, does_not_raise
@pytest.mark.parametrize(
"input_, key, value, expected",
[
# dict
(dict(), "foo", 10, dict(foo=10)),
(dict(), "foo", IntegerNode(10), dict(foo=10)),
(dict(foo=5), "foo", IntegerNode(10), dict(foo=10)),
# changing type of a node
(dict(foo=StringNode("str")), "foo", IntegerNode(10), dict(foo=10)),
# list
([0], 0, 10, [10]),
(["a", "b", "c"], 1, 10, ["a", 10, "c"]),
([1, 2], 1, IntegerNode(10), [1, 10]),
([1, IntegerNode(2)], 1, IntegerNode(10), [1, 10]),
# changing type of a node
([1, StringNode("str")], 1, IntegerNode(10), [1, 10]),
],
)
def test_set_value(
input_: Any, key: Union[str, int], value: Any, expected: Any
) -> None:
c = OmegaConf.create(input_)
c[key] = value
assert c == expected
def test_interpolation(self, node_type: Any, values: Any,
restore_resolvers: Any) -> None:
resolver_output = 9999
OmegaConf.register_resolver("func", lambda: resolver_output)
values = copy.deepcopy(values)
for value in values:
node = {
"reg": node_type(value=value, is_optional=False),
"opt": node_type(value=value, is_optional=True),
}
cfg = OmegaConf.create({
"const":
10,
"primitive_missing":
"???",
"resolver":
StringNode(value="${func:}", is_optional=False),
"opt_resolver":
StringNode(value="${func:}", is_optional=True),
"node":
DictConfig(content=node, is_optional=False),
"opt_node":
DictConfig(content=node, is_optional=True),
"reg":
node_type(value=value, is_optional=False),
"opt":
node_type(value=value, is_optional=True),
"opt_none":
node_type(value=None, is_optional=True),
"missing":
node_type(value="???", is_optional=False),
"opt_missing":
node_type(value="???", is_optional=True),
# Interpolations
"int_reg":
"${reg}",
"int_opt":
"${opt}",
"int_opt_none":
"${opt_none}",
"int_missing":
"${missing}",
"int_opt_missing":
"${opt_missing}",
"str_int_const":
StringNode(value="foo_${const}", is_optional=False),
"opt_str_int_const":
StringNode(value="foo_${const}", is_optional=True),
"str_int_with_primitive_missing":
StringNode(value="foo_${primitive_missing}",
is_optional=False),
"opt_str_int_with_primitive_missing":
StringNode(value="foo_${primitive_missing}", is_optional=True),
"int_node":
"${node}",
"int_opt_node":
"${opt_node}",
"int_resolver":
"${resolver}",
"int_opt_resolver":
"${opt_resolver}",
})
verify(cfg,
"const",
none=False,
opt=True,
missing=False,
inter=False,
exp=10)
verify(
cfg,
"resolver",
none=False,
# Note, resolvers are always optional because the underlying function may return None
opt=True,
missing=False,
inter=True,
exp=resolver_output,
)
verify(
cfg,
"opt_resolver",
none=False,
opt=True,
missing=False,
inter=True,
exp=resolver_output,
)
verify(
cfg,
"reg",
none=False,
opt=False,
missing=False,
inter=False,
exp=value,
)
verify(cfg,
"opt",
none=False,
opt=True,
missing=False,
inter=False,
exp=value)
verify(
cfg,
"opt_none",
none=True,
opt=True,
missing=False,
inter=False,
exp=None,
)
verify(cfg,
"missing",
none=False,
opt=False,
missing=True,
inter=False)
verify(cfg,
"opt_missing",
none=False,
opt=True,
missing=True,
inter=False)
verify(
cfg,
"int_reg",
none=False,
opt=False,
missing=False,
inter=True,
exp=value,
)
verify(
cfg,
"int_opt",
none=False,
opt=True,
missing=False,
inter=True,
exp=value,
)
verify(
cfg,
"int_opt_none",
none=True,
opt=True,
missing=False,
inter=True,
exp=None,
)
verify(cfg,
"int_missing",
none=False,
opt=False,
missing=True,
inter=True)
verify(cfg,
"int_opt_missing",
none=False,
opt=True,
missing=True,
inter=True)
verify(
cfg,
"str_int_const",
none=False,
opt=False,
missing=False,
inter=True,
exp="foo_10",
)
verify(
cfg,
"opt_str_int_const",
none=False,
opt=True,
missing=False,
inter=True,
exp="foo_10",
)
verify(
cfg,
"int_node",
none=False,
opt=False,
missing=False,
inter=True,
exp=node,
)
verify(
cfg,
"int_opt_node",
none=False,
opt=True,
missing=False,
inter=True,
exp=node,
)
verify(
cfg,
"int_resolver",
none=False,
opt=True,
missing=False,
inter=True,
exp=resolver_output,
)
verify(
cfg,
"int_opt_resolver",
none=False,
opt=True,
missing=False,
inter=True,
exp=resolver_output,
)
verify(
cfg,
"str_int_with_primitive_missing",
none=False,
opt=False,
missing=False,
inter=True,
)
verify(
cfg,
"opt_str_int_with_primitive_missing",
none=False,
opt=True,
missing=False,
inter=True,
)
c = OmegaConf.create([])
assert isinstance(c, ListConfig)
c.append(IntegerNode(10))
assert c.get(0) == 10
with pytest.raises(ValidationError):
c[0] = "string"
assert c[0] == 10
assert type(c._get_node(0)) == IntegerNode
# Test merge raises validation error
@pytest.mark.parametrize(
"c1, c2",
[
(dict(a=IntegerNode(10)), dict(a="str")),
(dict(a=IntegerNode(10)), dict(a=StringNode("str"))),
(dict(a=10, b=IntegerNode(10)), dict(a=20, b="str")),
(dict(foo=dict(bar=IntegerNode(10))), dict(foo=dict(bar="str"))),
],
)
def test_merge_validation_error(c1: Dict[str, Any], c2: Dict[str, Any]) -> None:
conf1 = OmegaConf.create(c1)
conf2 = OmegaConf.create(c2)
with pytest.raises(ValidationError):
OmegaConf.merge(conf1, conf2)
# make sure that conf1 and conf2 were not modified
assert conf1 == OmegaConf.create(c1)
assert conf2 == OmegaConf.create(c2)
@pytest.mark.parametrize(
OmegaConfUserResolver,
)
from tests import Color
@fixture
def resolver() -> Any:
yield OmegaConfUserResolver()
@mark.parametrize(
("obj", "expected"),
[
# nodes
param(AnyNode(10), {}, id="any:10"),
param(StringNode("foo"), {}, id="str:foo"),
param(IntegerNode(10), {}, id="int:10"),
param(FloatNode(3.14), {}, id="float:3.14"),
param(BooleanNode(True), {}, id="bool:True"),
param(BytesNode(b"binary"), {}, id="bytes:binary"),
param(EnumNode(enum_type=Color, value=Color.RED), {},
id="Color:Color.RED"),
# nodes are never returning a dictionary
param(AnyNode("${foo}", parent=DictConfig({"foo": 10})), {},
id="any:inter_10"),
# DictConfig
param(DictConfig({"a": 10}), {"a": AnyNode(10)}, id="dict"),
param(
DictConfig({
"a": 10,
"b": "${a}"
"bar": MISSING
},
"foo",
True,
raises(MissingMandatoryValue),
),
(
{
"foo": "${unknown_resolver:foo}"
},
"foo",
False,
raises(UnsupportedInterpolationType),
),
({
"foo": StringNode(value="???")
}, "foo", True, raises(MissingMandatoryValue)),
(
{
"foo": StringNode(value="???"),
"inter": "${foo}"
},
"inter",
True,
raises(MissingMandatoryValue),
),
(StructuredWithMissing, "num", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "opt_num", True,
raises(MissingMandatoryValue)),
(StructuredWithMissing, "dict", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "opt_dict", True,
id="missing_dict",
),
({"foo": "${bar}", "bar": MISSING}, "foo", True, raises(MissingMandatoryValue)),
(
{"foo": "foo_${bar}", "bar": MISSING},
"foo",
False,
raises(MissingMandatoryValue),
),
(
{"foo": "${unknown_resolver:foo}"},
"foo",
False,
raises(UnsupportedInterpolationType),
),
({"foo": StringNode(value="???")}, "foo", True, raises(MissingMandatoryValue)),
(
{"foo": StringNode(value="???"), "inter": "${foo}"},
"inter",
True,
raises(MissingMandatoryValue),
),
(StructuredWithMissing, "num", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "opt_num", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "dict", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "opt_dict", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "list", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "opt_list", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "user", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "opt_user", True, raises(MissingMandatoryValue)),
(StructuredWithMissing, "inter_user", True, raises(MissingMandatoryValue)),
c = OmegaConf.create([])
assert isinstance(c, ListConfig)
c.append(IntegerNode(10))
assert c.get(0) == 10
with raises(ValidationError):
c[0] = "string"
assert c[0] == 10
assert type(c._get_node(0)) == IntegerNode
# Test merge raises validation error
@mark.parametrize(
"c1, c2",
[
(dict(a=IntegerNode(10)), dict(a="str")),
(dict(a=IntegerNode(10)), dict(a=StringNode("str"))),
(dict(a=10, b=IntegerNode(10)), dict(a=20, b="str")),
(dict(foo=dict(bar=IntegerNode(10))), dict(foo=dict(bar="str"))),
],
)
def test_merge_validation_error(c1: Dict[str, Any], c2: Dict[str,
Any]) -> None:
conf1 = OmegaConf.create(c1)
conf2 = OmegaConf.create(c2)
with raises(ValidationError):
OmegaConf.merge(conf1, conf2)
# make sure that conf1 and conf2 were not modified
assert conf1 == OmegaConf.create(c1)
assert conf2 == OmegaConf.create(c2)
def test_list_integer_rejects_string():
c = OmegaConf.create([])
c.append(IntegerNode(10))
assert c.get(0) == 10
with pytest.raises(ValidationError):
c[0] = "string"
assert c[0] == 10
assert type(c.get_node(0)) == IntegerNode
# Test merge raises validation error
@pytest.mark.parametrize(
"c1, c2",
[
(dict(a=IntegerNode(10)), dict(a="str")),
(dict(a=IntegerNode(10)), dict(a=StringNode("str"))),
(dict(a=10, b=IntegerNode(10)), dict(a=20, b="str")),
(dict(foo=dict(bar=IntegerNode(10))), dict(foo=dict(bar="str"))),
],
)
def test_merge_validation_error(c1, c2):
conf1 = OmegaConf.create(c1)
conf2 = OmegaConf.create(c2)
with pytest.raises(ValidationError):
OmegaConf.merge(conf1, conf2)
# make sure that conf1 and conf2 were not modified
assert conf1 == OmegaConf.create(c1)
assert conf2 == OmegaConf.create(c2)