def test_select():
context = Context(foo="foo", bar="bar", lst=[1, 2, 3])
assert context.select("foo") == Value("foo")
assert context.select("bar") == Value("bar")
assert context.select("lst") == CtxList([1, 2, 3])
assert context.select("lst.0") == Value(1)
with pytest.raises(KeyNotInContext):
context.select("baz")
d = {
"lst": [
{
"foo0": "foo0",
"bar0": "bar0"
},
{
"foo1": "foo1",
"bar1": "bar1"
},
]
}
context = Context(d)
assert context.select("lst") == CtxList(d["lst"])
assert context.select("lst.0") == CtxDict(d["lst"][0])
assert context.select("lst.1") == CtxDict(d["lst"][1])
with pytest.raises(KeyNotInContext):
context.select("lst.2")
for i, _ in enumerate(d["lst"]):
assert context.select(f"lst.{i}.foo{i}") == Value(f"foo{i}")
assert context.select(f"lst.{i}.bar{i}") == Value(f"bar{i}")
def test_loop_context():
context = Context({"foo": "foo", "bar": "bar", "lst": [1, 2, 3]})
assert list(context) == ["foo", "bar", "lst"]
assert len(context) == 3
assert list(context["lst"]) == [Value(i) for i in [1, 2, 3]]
assert len(context["lst"]) == 3
assert list(context.items()) == [
("foo", Value("foo")),
("bar", Value("bar")),
("lst", CtxList([1, 2, 3])),
]
def test_context():
context = Context({"foo": "bar"})
assert context["foo"] == Value("bar")
context = Context(foo="bar")
assert context["foo"] == Value("bar")
context["foobar"] = "foobar"
assert context["foobar"] == Value("foobar")
del context["foobar"]
assert "foobar" not in context
assert "foo" in context
with pytest.raises(KeyError):
_ = context["foobar"]
def test_set_already_exists():
context = Context({"item": "foo"})
with pytest.raises(ValueError,
match="Cannot set 'item', key already exists"):
DataResolver.set_context_from(context, {"item": "bar"})
assert context["item"] == Value("foo")
def test_context_setitem_getitem():
context = Context()
lst = [1, 2, "three", True, pi, b"bytes", None]
context["list"] = lst
assert isinstance(context["list"], CtxList)
assert context["list"] == CtxList(lst)
for i, val in enumerate(lst):
assert context["list"][i] == Value(val)
d = {
"foo":
"foo",
"bar":
"bar",
"list": [
{
"foo0": "foo0",
"bar0": "bar0"
},
{
"foo1": "foo1",
"bar1": "bar1"
},
],
}
context["data"] = d
assert isinstance(context["data"], CtxDict)
assert context["data"] == CtxDict(d)
assert context["data"]["foo"] == Value("foo")
assert context["data"]["bar"] == Value("bar")
assert isinstance(context["data"]["list"], CtxList)
assert context["data"]["list"] == CtxList(d["list"])
for i, val in enumerate(d["list"]):
c = context["data"]["list"][i]
assert isinstance(c, CtxDict)
assert c == CtxDict(val)
assert c[f"foo{i}"] == Value(f"foo{i}")
assert c[f"bar{i}"] == Value(f"bar{i}")
with pytest.raises(TypeError):
context["set"] = {1, 2, 3}
def test_set_already_exists():
context = Context({"item": "foo"})
with pytest.raises(ResolveError) as exc_info:
DataResolver.set_context_from(context, {"item": "bar"})
assert (
str(exc_info.value) == "Failed to set 'item': Cannot set 'item', "
"key already exists"
)
assert context["item"] == Value("foo")
def test_merge_dict():
d1 = {"Train": {"us": {"lr": 10}}}
d2 = {"Train": {"us": {"layers": 100}}}
c1 = Context(d1)
c2 = Context(d2)
c1.merge_update(c2)
assert c1.select("Train.us") == CtxDict(lr=10, layers=100)
with pytest.raises(MergeError):
# cannot overwrite by default
c1.merge_update({"Train": {"us": {"lr": 15}}})
c1.merge_update({"Train": {"us": {"lr": 15}}}, overwrite=True)
node = c1.select("Train.us")
assert node == {"lr": 15, "layers": 100}
assert isinstance(node, CtxDict)
assert node["lr"] == Value(15)
assert node["layers"] == Value(100)
def test_merge_list():
c1 = Context(lst=[1, 2, 3])
with pytest.raises(MergeError):
# cannot overwrite by default
c1.merge_update({"lst": [10, 11, 12]})
# lists are never merged
c1.merge_update({"lst": [10, 11, 12]}, overwrite=True)
node = c1.select("lst")
assert node == [10, 11, 12]
assert isinstance(node, CtxList)
assert node[0] == Value(10)
def test_set_interpolated_string():
context = Context(CONTEXT_DATA)
DataResolver.set_context_from(
context,
{
"foo": "${dict.foo}",
"bar": "${dict.bar}",
"param1": "${list[0]}",
"param2": "${list[1]}",
"frozen": "${freeze}",
"dict2": "${dict}",
"list2": "${list}",
},
)
assert context["foo"] == Value("foo")
assert context["bar"] == Value("bar")
assert context["param1"] == Value("param1")
assert context["param2"] == Value("param2")
assert context["frozen"] == context["freeze"] == Value(True)
assert context["dict2"] == context["dict"] == CONTEXT_DATA["dict"]
assert context["list2"] == context["list"] == CONTEXT_DATA["list"]
def test_set_ladder():
context = Context(CONTEXT_DATA)
DataResolver.set_context_from(
context,
{
"item": 5,
"foo": "${dict.foo}",
"bar": "${dict.bar}",
"bar2": "${bar}",
"dict2": "${dict}",
"list2": "${list}",
"dict3": "${dict2}",
"list3": "${list2}",
},
)
assert context["item"] == Value(5)
assert context["foo"] == context["dict"]["foo"] == Value("foo")
assert (
context["bar"]
== context["bar2"]
== context["dict"]["bar"]
== Value("bar")
)
assert (
context["dict"]
== context["dict2"]
== context["dict3"]
== CONTEXT_DATA["dict"]
)
assert (
context["list"]
== context["list2"]
== context["list3"]
== CONTEXT_DATA["list"]
)
def test_context_list():
lst = ["foo", "bar", "baz"]
context = Context(lst=lst)
assert context["lst"] == CtxList(lst)
assert context["lst"][0] == Value("foo")
del context["lst"][-1]
assert "baz" not in context
with pytest.raises(IndexError):
_ = context["lst"][3]
context["lst"].insert(0, "baz")
assert context["lst"] == CtxList(["baz"] + lst[:2])
def test_clone():
d = {
"dct": {
"foo0": "foo0",
"bar0": "bar0",
"foo1": "foo1",
"bar1": "bar1",
},
"lst": [1, 2, 3],
}
c1 = Context(d)
c2 = Context.clone(c1)
c2["dct"]["foo0"] = "foo"
del c2["dct"]["foo1"]
assert c1 != c2
assert c1 == Context(d)
assert c2.select("lst.0") == Value(1)
with pytest.raises(KeyNotInContext):
c2.select("lst.1.not_existing_key")
def test_clone():
d = {
"lst": [
{
"foo0": "foo0",
"bar0": "bar0"
},
{
"foo1": "foo1",
"bar1": "bar1"
},
]
}
c1 = Context(d)
c2 = Context.clone(c1)
c2["lst"][0]["foo0"] = "foo"
del c2["lst"][1]["foo1"]
assert c1 != c2
assert c1 == Context(d)
assert c2.select("lst.0.foo0") == Value("foo")
with pytest.raises(ValueError):
c2.select("lst.1.foo1")
def test_overwrite_with_setitem():
context = Context(foo="foo", d={"bar": "bar", "baz": "baz"})
context["d"] = "overwrite"
assert "d" in context
assert context["d"] == Value("overwrite")
