def test_union_merge_matrix(
lhs: Any,
rhs: Any,
) -> None:
lhs = _ensure_container(lhs)
rhs = _ensure_container(rhs)
lnode = lhs._get_node("foo")
rnode = rhs._get_node("foo")
lvalue = _get_value(lnode)
rvalue = _get_value(rnode)
# lvk = get_value_kind(lnode)
rvk = get_value_kind(rnode)
rmissing = rvk is ValueKind.MANDATORY_MISSING
can_merge = True
if can_merge:
merged = OmegaConf.merge(lhs, rhs)
if rmissing:
assert merged == {"foo": lvalue}
else:
assert merged == {"foo": rvalue}
else:
with raises(ValidationError):
OmegaConf.merge(lhs, rhs)
def test_get_value_basic(value: Any) -> None:
val_node = _node_wrap(value=value,
type_=Any,
parent=None,
is_optional=True,
key=None)
assert _get_value(val_node) == value
def visit() -> Any:
return _utils._get_value(
cfg.resolve_parse_tree(
parse_tree,
key=None,
parent=cfg,
))
def test_get_value_basic(value: Any) -> None:
val_node = _node_wrap(value=value,
ref_type=Any,
parent=None,
is_optional=True,
key=None)
result = _get_value(val_node)
assert result == value
def visit() -> Any:
return _utils._get_value(
cfg.resolve_parse_tree(
parse_tree,
# Create a dummy `AnyNode` (it should not actually be used in these
# grammer tests, but `resolve_parse_tree()` requires it).
node=AnyNode(None, parent=cfg),
key=None,
))
def test_creation(self, input_: Any, union_args: Any) -> None:
ref_type = Union[union_args] # type: ignore
legal = type(input_) in union_args
if legal:
node = UnionNode(input_, ref_type)
assert _get_value(node) == input_
else:
with raises(ValidationError):
UnionNode(input_, ref_type)
def decode(expr: Optional[str], _parent_: Container, _node_: Node) -> Any:
"""
Parse and evaluate `expr` according to the `singleElement` rule of the grammar.
If `expr` is `None`, then return `None`.
"""
if expr is None:
return None
if not isinstance(expr, str):
raise TypeError(f"`oc.decode` can only take strings or None as input, "
f"but `{expr}` is of type {type(expr).__name__}")
parse_tree = parse(expr,
parser_rule="singleElement",
lexer_mode="VALUE_MODE")
val = _parent_.resolve_parse_tree(parse_tree, node=_node_)
return _get_value(val)
def test_get_value_container(content: Any) -> None:
cfg = DictConfig({})
cfg._set_value(content)
assert _get_value(cfg) == content
def test_get_value_of_node_subclass(node: Node, expected: Any) -> None:
result = _get_value(node)
assert result == expected
assert type(result) == type(expected)
