more files

Signed-off-by: Thijs Baaijen <[email protected]>

Author: Thijss

src/power_grid_model_ds/_core/data_source/generator/arrays/transformer.py

@@ -17,21 +17,21 @@ def run(self, amount: int) -> TransformerArray:
         """Generate transformers"""
 
         # Create transformers from 10kV to 3kV
-        from_mask = self.grid.node.u_rated == 10_500
-        from_nodes = self.rng.choice(self.grid.node.id[from_mask], amount, replace=True)
-        to_mask = self.grid.node.u_rated == 3_000
-        to_nodes = self.rng.choice(self.grid.node.id[to_mask], amount, replace=False)
+        from_mask = self.grid.node["u_rated"] == 10_500
+        from_nodes = self.rng.choice(self.grid.node["id"][from_mask], amount, replace=True)
+        to_mask = self.grid.node["u_rated"] == 3_000
+        to_nodes = self.rng.choice(self.grid.node["id"][to_mask], amount, replace=False)
         transformer_array = self.grid.transformer.__class__.zeros(amount)
-        transformer_array.id = 1 + self.grid.max_id + np.arange(amount)
-        transformer_array.from_node = from_nodes
-        transformer_array.to_node = to_nodes
-        transformer_array.from_status = [1] * amount
-        transformer_array.to_status = [1] * amount
-        transformer_array.u1 = [10_500] * amount
-        transformer_array.u2 = [3_000] * amount
-        transformer_array.sn = [30e6] * amount
-        transformer_array.clock = [12] * amount
-        transformer_array.uk = [0.203] * amount
-        transformer_array.pk = [100e3] * amount
+        transformer_array["id"] = 1 + self.grid.max_id + np.arange(amount)
+        transformer_array["from_node"] = from_nodes
+        transformer_array["to_node"] = to_nodes
+        transformer_array["from_status"] = [1] * amount
+        transformer_array["to_status"] = [1] * amount
+        transformer_array["u1"] = [10_500] * amount
+        transformer_array["u2"] = [3_000] * amount
+        transformer_array["sn"] = [30e6] * amount
+        transformer_array["clock"] = [12] * amount
+        transformer_array["uk"] = [0.203] * amount
+        transformer_array["pk"] = [100e3] * amount
 
         return transformer_array

tests/integration/loadflow/test_power_grid_model.py

@@ -165,7 +165,7 @@ def test_batch_run(self):
         core_interface = PowerGridModelInterface(grid=grid)
 
         update_sym_load = initialize_array("update", "sym_load", (10, len(grid.sym_load)))
-        update_sym_load["id"] = [grid.sym_load.id.tolist()]
+        update_sym_load["id"] = [grid.sym_load["id"].tolist()]
         update_sym_load["p_specified"] = [grid.sym_load.p_specified.tolist()] * np.linspace(0, 1, 10).reshape(-1, 1)
         update_sym_load["q_specified"] = [grid.sym_load.q_specified.tolist()] * np.linspace(0, 1, 10).reshape(-1, 1)
         update_data = {

tests/integration/visualizer_tests.py

@@ -22,10 +22,10 @@ def get_radial_grid() -> Grid:
 def get_coordinated_grid() -> CoordinatedGrid:
     scale = 500
     grid = CoordinatedGrid.from_txt("S1 2 open", "2 3", "3 4", "S1 500000000", "500000000 6", "6 7 transformer")
-    grid.node.x = [3, 2.5, 2, 1.5, 3.5, 4, 4.5]
-    grid.node.x *= scale
-    grid.node.y = [3, 4, 3, 4, 3, 4, 3]
-    grid.node.y *= scale
+    grid.node["x"] = [3, 2.5, 2, 1.5, 3.5, 4, 4.5]
+    grid.node["x"] *= scale
+    grid.node["y"] = [3, 4, 3, 4, 3, 4, 3]
+    grid.node["y"] *= scale
     return grid
 
 

tests/unit/model/arrays/test_modify.py

@@ -14,18 +14,18 @@
 
 class TestReorder:
     def test_reorder_by_id(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         reordered = fancy_test_array.re_order([3, 1, 2])
-        assert_array_equal(reordered.id, [3, 1, 2])
-        assert_array_equal(reordered.test_str, ["d", "a", "c"])
+        assert_array_equal(reordered["id"], [3, 1, 2])
+        assert_array_equal(reordered["test_str"], ["d", "a", "c"])
 
     def test_reorder_by_test_str(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         reordered = fancy_test_array.re_order(["d", "a", "c"], column="test_str")
-        assert_array_equal(reordered.id, [3, 1, 2])
-        assert_array_equal(reordered.test_str, ["d", "a", "c"])
+        assert_array_equal(reordered["id"], [3, 1, 2])
+        assert_array_equal(reordered["test_str"], ["d", "a", "c"])
 
     def test_reorder_mismatched_length(self, fancy_test_array: FancyTestArray):
         with pytest.raises(ValueError):
@@ -34,30 +34,30 @@ def test_reorder_mismatched_length(self, fancy_test_array: FancyTestArray):
 
 class TestUpdateById:
     def test_get_update_by_id(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         updated = fancy_test_array.get_updated_by_id([1, 3], test_str="e")
 
-        assert_array_equal(updated.id, [1, 3])
-        assert_array_equal(updated.test_str, ["e", "e"])
+        assert_array_equal(updated["id"], [1, 3])
+        assert_array_equal(updated["test_str"], ["e", "e"])
 
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["e", "c", "e"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["e", "c", "e"])
 
     def test_get_update_by_id_duplicate_id_input(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         updated = fancy_test_array.get_updated_by_id([1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3], test_str="e")
 
-        assert_array_equal(updated.id, [1, 3])
+        assert_array_equal(updated["id"], [1, 3])
 
     def test_update_by_id_multiple_columns(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         fancy_test_array.update_by_id([1, 3], test_str="e", test_int=[88, 99])
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["e", "c", "e"])
-        assert_array_equal(fancy_test_array.test_int, [88, 0, 99])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["e", "c", "e"])
+        assert_array_equal(fancy_test_array["test_int"], [88, 0, 99])
 
     def test_update_by_id_invalid_column(self, fancy_test_array: FancyTestArray):
         with pytest.raises(ValueError):
@@ -73,7 +73,7 @@ def test_update_by_id_invalid_id(self, fancy_test_array: FancyTestArray):
 
     def test_update_by_id_invalid_id_allow_missing(self, fancy_test_array: FancyTestArray):
         fancy_test_array.update_by_id([1, 4], test_str="e", allow_missing=True)
-        assert fancy_test_array.get(1).record.test_str == "e"
+        assert fancy_test_array.get(1)["test_str"] == "e"
 
     def test_update_by_id_no_id_column(self):
         fancy_non_id_array = FancyNonIdArray.zeros(10)
@@ -87,11 +87,11 @@ def test_update_by_id_non_existing_id(self, fancy_test_array: FancyTestArray):
 
 class TestConcatenate:
     def test_concatenate_fancy_array(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         concatenated = fp.concatenate(fancy_test_array, fancy_test_array)
-        assert_array_equal(concatenated.id, [1, 2, 3, 1, 2, 3])
-        assert_array_equal(concatenated.test_str, ["a", "c", "d", "a", "c", "d"])
+        assert_array_equal(concatenated["id"], [1, 2, 3, 1, 2, 3])
+        assert_array_equal(concatenated["test_str"], ["a", "c", "d", "a", "c", "d"])
 
     def test_concatenate_to_empty_array(self, fancy_test_array: FancyTestArray):
         empty_array = FancyTestArray()
@@ -104,18 +104,18 @@ def test_concatenate_empty_arrays(self):
         assert concatenated.size == 0
 
     def test_concatenate_multiple_fancy_arrays(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         concatenated = fp.concatenate(fancy_test_array, fancy_test_array, fancy_test_array)
-        assert_array_equal(concatenated.id, [1, 2, 3, 1, 2, 3, 1, 2, 3])
-        assert_array_equal(concatenated.test_str, ["a", "c", "d", "a", "c", "d", "a", "c", "d"])
+        assert_array_equal(concatenated["id"], [1, 2, 3, 1, 2, 3, 1, 2, 3])
+        assert_array_equal(concatenated["test_str"], ["a", "c", "d", "a", "c", "d", "a", "c", "d"])
 
     def test_concatenate_ndarray(self, fancy_test_array: FancyTestArray):
-        assert_array_equal(fancy_test_array.id, [1, 2, 3])
-        assert_array_equal(fancy_test_array.test_str, ["a", "c", "d"])
+        assert_array_equal(fancy_test_array["id"], [1, 2, 3])
+        assert_array_equal(fancy_test_array["test_str"], ["a", "c", "d"])
         concatenated = fp.concatenate(fancy_test_array, fancy_test_array.data)
-        assert_array_equal(concatenated.id, [1, 2, 3, 1, 2, 3])
-        assert_array_equal(concatenated.test_str, ["a", "c", "d", "a", "c", "d"])
+        assert_array_equal(concatenated["id"], [1, 2, 3, 1, 2, 3])
+        assert_array_equal(concatenated["test_str"], ["a", "c", "d", "a", "c", "d"])
 
     def test_concatenate_different_fancy_array(self, fancy_test_array: FancyTestArray):
         different_array = FancyNonIdArray.zeros(10)
@@ -131,7 +131,7 @@ def test_concatenate_different_fancy_array_same_dtype(self, fancy_test_array: Fa
         sub_array = fancy_test_array[["test_str", "test_int"]]
 
         different_array = FancyNonIdArray.zeros(10)
-        different_sub_array = different_array[["test_str", "test_int"]]
+        different_sub_array = different_array.data[["test_str", "test_int"]]
 
         concatenated = np.concatenate([sub_array, different_sub_array])
         assert concatenated.size == 13

tests/unit/model/arrays/test_pgm_arrays.py

@@ -13,24 +13,24 @@
 @pytest.fixture(name="branches")
 def parallel_branches():
     branches = BranchArray.zeros(3)
-    branches.from_node = [0, 0, 1]
-    branches.to_node = [1, 1, 2]
+    branches["from_node"] = [0, 0, 1]
+    branches["to_node"] = [1, 1, 2]
     return branches
 
 
 class TestBranchArray:
     def test_branch_is_active(self):
         branches = BranchArray.zeros(4)
-        branches.from_status = [1, 1, 0, 0]
-        branches.to_status = [1, 0, 1, 0]
+        branches["from_status"] = [1, 1, 0, 0]
+        branches["to_status"] = [1, 0, 1, 0]
 
         assert_array_equal(branches.is_active, [True, False, False, False])
         assert branches[0].is_active
 
     def test_branch_node_ids(self):
         branches = BranchArray.zeros(2)
-        branches.from_node = [0, 1]
-        branches.to_node = [1, 2]
+        branches["from_node"] = [0, 1]
+        branches["to_node"] = [1, 2]
 
         assert_array_equal(branches.node_ids, [0, 1, 1, 2])
 
@@ -58,10 +58,10 @@ def test_as_branches_single(self):
 
         assert branch_array.size == 3
 
-        assert branch_array.from_node.tolist() == [1, 1, 2]
-        assert branch_array.to_node.tolist() == [2, 3, 3]
-        assert branch_array.from_status.tolist() == [1, 1, 1]
-        assert branch_array.to_status.tolist() == [1, 0, 0]
+        assert branch_array["from_node"].tolist() == [1, 1, 2]
+        assert branch_array["to_node"].tolist() == [2, 3, 3]
+        assert branch_array["from_status"].tolist() == [1, 1, 1]
+        assert branch_array["to_status"].tolist() == [1, 0, 0]
 
     def test_as_branches_multiple(self):
         branch3 = Branch3Array(
@@ -77,7 +77,7 @@ def test_as_branches_multiple(self):
         branch_array.sort(order=["from_node", "to_node"])
 
         assert branch_array.size == 6
-        assert branch_array.from_node.tolist() == [1, 1, 2, 4, 4, 5]
-        assert branch_array.to_node.tolist() == [2, 3, 3, 5, 6, 6]
-        assert branch_array.from_status.tolist() == [1, 1, 1, 1, 1, 1]
-        assert branch_array.to_status.tolist() == [1, 1, 1, 1, 0, 0]
+        assert branch_array["from_node"].tolist() == [1, 1, 2, 4, 4, 5]
+        assert branch_array["to_node"].tolist() == [2, 3, 3, 5, 6, 6]
+        assert branch_array["from_status"].tolist() == [1, 1, 1, 1, 1, 1]
+        assert branch_array["to_status"].tolist() == [1, 1, 1, 1, 0, 0]

tests/unit/model/arrays/test_string.py

@@ -24,7 +24,7 @@ def test_str_empty_array():
 
 def test_str_large_array():
     array = FancyTestArray.zeros(100)
-    array.test_str = "ABC"
+    array["test_str"] = "ABC"
     array_str = str(array)
 
     splits = array_str.replace("\n", "|").split("|")
@@ -44,8 +44,8 @@ def test_str_long_column_name():
 
 def test_str_long_values():
     array = FancyTestArray.zeros(1)
-    array.test_str = "this_is_a_very_long_value"
-    array.test_int = 112233445566778899
+    array["test_str"] = "this_is_a_very_long_value"
+    array["test_int"] = 112233445566778899
     array_str = array.as_table(column_width=15)
 
     splits = array_str.replace("\n", "|").split("|")
@@ -63,8 +63,8 @@ def test_str_long_column_name_autosize():
 
 def test_str_long_values_autosize():
     array = FancyTestArray.zeros(1)
-    array.test_str = "this_is_a_very_long_value"
-    array.test_int = 112233445566778899
+    array["test_str"] = "this_is_a_very_long_value"
+    array["test_int"] = 112233445566778899
     array_str = str(array)
     assert "| this_is_a_very_long_value" in array_str
     assert "| 112233445566778899" in array_str