def test_include(self):
key = "list1.1.list2.32"
includes = "list1.list2", "ok"
result = FlatData._include(key, includes)
expected_result = True
assert result == expected_result
includes = "list1", "ok"
result = FlatData._include(key, includes)
expected_result = False
assert result == expected_result
def _get_data():
# Make the tree
site_nodes = LengthNode(2)
line_nodes = [LengthNode(1), LengthNode(1)]
tank_nodes_site0 = [LengthNode(3)]
tank_nodes_site1 = [LengthNode(4)]
site_nodes.set_children(line_nodes)
line_nodes[0].set_children(tank_nodes_site0)
line_nodes[1].set_children(tank_nodes_site1)
nodes = [site_nodes]
nodes.extend(line_nodes)
nodes.extend(tank_nodes_site0)
nodes.extend(tank_nodes_site1)
level_names = "IDX_SITE", "IDX_LINE", "IDX_TANK"
flat_results = FlatData({
"sites[0].lines[0].tanks[0].Q_yield": 10.0,
"sites[0].lines[0].tanks[1].Q_yield": 6.0,
"sites[0].lines[0].tanks[2].Q_yield": 4.0,
"sites[1].lines[0].tanks[0].Q_yield": 20.0,
"sites[1].lines[0].tanks[1].Q_yield": 8.0,
"sites[1].lines[0].tanks[2].Q_yield": 3.0,
"sites[1].lines[0].tanks[3].Q_yield": 1.0,
})
tree = LengthTree(nodes, level_names)
print("tree", tree)
return tree, flat_results
def test_status(self):
"""Check the status string representation completes"""
self.get_worker_counts([[self.querystr_level0]])
flat_results = FlatData({"hello.world": 5})
self.qr.flat_results = flat_results
expanded_paths = [HubitQueryPath("hello.world")]
self.qr._status(flat_results, expanded_paths)
def test_from_dict_stop_at_level1(self):
"""
Test stop at level 1
"""
data = {
"level0": {
"level1": [{
"attr1": 1
}, {
"attr2": 2
}]
},
"number": 3
}
include_path = "level0.level1"
result = FlatData.from_dict(data,
stop_at=[re.compile(include_path)],
include_patterns=[include_path])
expected_result = {
"level0.level1": [{
"attr1": 1
}, {
"attr2": 2
}],
}
print(result)
assert result == expected_result
def test_from_dict_stop_at_level1_list(self):
"""
Test stop at root level
"""
data = {
"level0": [{
"level1": [1, 2, 3, 4],
"ff": 4
}, {
"level1": [2, 5],
"gg": 5
}],
"number":
3,
}
spec = _HubitQueryDepthPath("level0[*].level1")
specs = [spec.compile_regex()]
result = FlatData.from_dict(
data,
stop_at=specs,
include_patterns=[
"level0.level1", "level0.ff", "level0.gg", "number"
],
)
print(result)
expected_result = {
"level0[0].level1": [1, 2, 3, 4],
"level0[0].ff": 4,
"level0[1].level1": [2, 5],
"level0[1].gg": 5,
"number": 3,
}
assert result == expected_result
def test_from_dict(self):
"""
Test nested dict
"""
data = {
"level1": {
"level2": [{
"attr1": 1
}, {
"attr2": 2
}]
},
"number": 3
}
result = FlatData.from_dict(
data,
include_patterns=["level1.level2.attr1", "level1.level2.attr2"])
expected_result = {
"level1.level2[0].attr1": 1,
"level1.level2[1].attr2": 2,
}
self.assertTrue(
all([isinstance(key, HubitQueryPath) for key in result.keys()]))
assert result == expected_result
def skipfun(flat_input: FlatData) -> bool:
"""
Skip factor combination if the thickness of the two wall segments differ
"""
input = flat_input.inflate()
inner_materials = [
segment["layers"][0]["material"]
for segment in input["segments"].values() if segment["type"] == "wall"
]
different_inner_mat = len(set(inner_materials)) > 1
outer_materials = [
segment["layers"][len(segment["layers"]) - 1]["material"]
for segment in input["segments"].values() if segment["type"] == "wall"
]
different_outer_mat = len(set(outer_materials)) > 1
seg_thcks = [
sum([layer["thickness"] for layer in segment["layers"].values()])
for segment in input["segments"].values() if segment["type"] == "wall"
]
ref = seg_thcks[0]
not_all_eq_tck = not all(
[isclose(ref, seg_thck, rel_tol=1e-5) for seg_thck in seg_thcks[1:]])
return not_all_eq_tck or different_inner_mat or different_outer_mat
def get_worker_counts(self, queries):
flat_input = FlatData.from_dict(
self.input,
stop_at=self.model_cfg.compiled_query_depths,
include_patterns=self.model_cfg.include_patterns,
)
self.qr.reset()
worker_counts = []
for qpaths in queries:
self.qr.spawn_workers(qpaths, flat_input, flat_input, dryrun=True)
worker_counts.append(len(self.qr.workers))
return worker_counts
def test_from_dict_with_simple_list(self):
"""
Test flattening of simple list
"""
data = {"list": [1, 2, 3], "level0": {"list": [1, 2, 3]}}
result = FlatData.from_dict(data,
include_patterns=["list", "level0.list"])
expected_result = {
"list[0]": 1,
"list[1]": 2,
"list[2]": 3,
"level0.list[0]": 1,
"level0.list[1]": 2,
"level0.list[2]": 3,
}
assert result == expected_result
def test_cartesian_product_method(self):
query_paths = []
query = Query.from_paths(query_paths)
input_values_for_path = {
"segments[2].layers[2].material": ("brick", "concrete"),
"segments[0].layers[2].thickness": (0.08, 0.12),
}
hmodel = HubitModel(
HubitModelConfig.from_cfg(yaml.load(model, Loader=yaml.FullLoader),
base_path=THIS_DIR))
flat_inputs, args = hmodel._cartesian_product_method(
query,
input_values_for_path,
)
expected_inputs = [
{
"segments[2].layers[2].material": "brick",
"segments[0].layers[2].thickness": 0.08,
},
{
"segments[2].layers[2].material": "brick",
"segments[0].layers[2].thickness": 0.12,
},
{
"segments[2].layers[2].material": "concrete",
"segments[0].layers[2].thickness": 0.08,
},
{
"segments[2].layers[2].material": "concrete",
"segments[0].layers[2].thickness": 0.12,
},
]
assert flat_inputs == expected_inputs
for i, arg in enumerate(args):
assert type(arg[0]) == _QueryRunner
assert type(arg[1]) == Query
assert arg[2] == expected_inputs[i]
assert arg[3] == FlatData()
def test_from_dict_stop_at_level0(self):
"""
Test stop at root level
"""
data = {
"level0": {
"level1": [{
"attr1": 1
}, {
"attr2": 2
}]
},
"number": 3
}
result = FlatData.from_dict(
data,
stop_at=[re.compile("level0")],
include_patterns=["level0", "number"],
)
expected_result = data
assert result == expected_result
def test_from_dict_stop_at_level0_a(self):
"""
Test stop at level0. level1 also specified but is preceded
by level0
"""
data = {
"level0": {
"level1": [{
"attr1": 1
}, {
"attr2": 2
}]
},
"number": 3
}
include_path = "level0"
result = FlatData.from_dict(
data,
stop_at=[re.compile(include_path)],
include_patterns=[include_path, "number"],
)
expected_result = data
assert result == expected_result