still fixing some bugs

Signed-off-by: DONNOT Benjamin <[email protected]>

Author: BDonnot

grid2op/Environment/environment.py

@@ -491,6 +491,7 @@ def _init_backend(
         _no_overflow_disconnection = self._no_overflow_disconnection
         self._no_overflow_disconnection = True
         self._last_obs = None
+        self._called_from_reset = True
         *_, fail_to_start, info = self.step(do_nothing)
         self._no_overflow_disconnection = _no_overflow_disconnection
 
@@ -499,7 +500,8 @@ def _init_backend(
                 "Impossible to initialize the powergrid, the powerflow diverge at iteration 0. "
                 "Available information are: {}".format(info)
             ) from info["exception"][0]
-
+        self._called_from_reset = False
+        
         # test the backend returns object of the proper size
         if need_process_backend:
 

grid2op/tests/test_Observation.py

@@ -2522,10 +2522,12 @@ def test_change_line_status(self):
         # Create change action
         change_act = self.env.action_space({"change_line_status": change_status})
         # Simulate & Step
-        self.sim_obs, reward_sim, done_sim, _ = self.obs.simulate(change_act)
-        self.step_obs, reward_real, done_real, _ = self.env.step(change_act)
-        assert not done_sim
-        assert not done_real
+        self.sim_obs, reward_sim, done_simulate, info_simu = self.obs.simulate(change_act)
+        self.step_obs, reward_real, done_step, info_step = self.env.step(change_act)
+        assert not done_simulate, f"simulate is done, this should not be"
+        assert not done_step, f"step is done, this should not be"
+        assert not info_simu["exception"]
+        assert not info_step["exception"]
         assert abs(reward_sim - reward_real) <= 1e-7
         # Test observations are the same
         if self.sim_obs != self.step_obs:
@@ -2540,8 +2542,12 @@ def test_set_line_status(self):
         # Create set action
         set_act = self.env.action_space({"set_line_status": set_status})
         # Simulate & Step
-        self.sim_obs, _, _, _ = self.obs.simulate(set_act)
-        self.step_obs, _, _, _ = self.env.step(set_act)
+        self.sim_obs, _, done_simulate, info_simu = self.obs.simulate(set_act)
+        self.step_obs, _, done_step, info_step = self.env.step(set_act)
+        assert not done_simulate, f"simulate is done, this should not be"
+        assert not done_step, f"step is done, this should not be"
+        assert not info_simu["exception"]
+        assert not info_step["exception"]
         # Test observations are the same
         if self.sim_obs != self.step_obs:
             diff_, attr_diff = self.sim_obs.where_different(self.step_obs)
@@ -2554,21 +2560,26 @@ def test_change_bus(self):
                 "change_bus": {
                     "loads_id": [0],
                     "generators_ids": [0],
-                    "lines_or_id": [0],
+                    # "lines_or_id": [0],
                     "lines_ex_id": [0],
                 }
             }
         )
         # Simulate & Step
-        self.sim_obs, _, _, _ = self.obs.simulate(change_act)
-        self.step_obs, _, _, _ = self.env.step(change_act)
+        self.sim_obs, _, done_simulate, info_simu = self.obs.simulate(change_act)
+        self.step_obs, _, done_step, info_step = self.env.step(change_act)
+        assert not done_simulate, f"simulate is done, this should not be"
+        assert not done_step, f"step is done, this should not be"
+        assert not info_simu["exception"]
+        assert not info_step["exception"]
+        
         assert isinstance(
             self.sim_obs, type(self.step_obs)
         ), "sim_obs is not the same type as the step"
         assert isinstance(
             self.step_obs, type(self.sim_obs)
         ), "step is not the same type as the simulation"
-
+        
         # Test observations are the same
         if self.sim_obs != self.step_obs:
             diff_, attr_diff = self.sim_obs.where_different(self.step_obs)
@@ -2587,14 +2598,18 @@ def test_set_bus(self):
                 "set_bus": {
                     "loads_id": [(0, new_load_bus)],
                     "generators_ids": [(0, new_gen_bus)],
-                    "lines_or_id": [(0, new_lor_bus)],
+                    # "lines_or_id": [(0, new_lor_bus)],
                     "lines_ex_id": [(0, new_lex_bus)],
                 }
             }
         )
         # Simulate & Step
-        self.sim_obs, _, _, _ = self.obs.simulate(set_act)
-        self.step_obs, _, _, _ = self.env.step(set_act)
+        self.sim_obs, reward_sim, done_simulate, info_simu = self.obs.simulate(set_act)
+        self.step_obs, reward_real, done_step, info_step = self.env.step(set_act)
+        assert not done_simulate, f"simulate is done, this should not be"
+        assert not done_step, f"step is done, this should not be"
+        assert not info_simu["exception"]
+        assert not info_step["exception"]
         # Test observations are the same
         if self.sim_obs != self.step_obs:
             diff_, attr_diff = self.sim_obs.where_different(self.step_obs)
@@ -2610,8 +2625,13 @@ def test_redispatch(self):
         # Create redispatch action
         redisp_act = self.env.action_space({"redispatch": [(gen_id, redisp_val)]})
         # Simulate & Step
-        self.sim_obs, _, _, _ = self.obs.simulate(redisp_act)
-        self.step_obs, _, _, _ = self.env.step(redisp_act)
+        self.sim_obs, reward_sim, done_simulate, info_simu = self.obs.simulate(redisp_act)
+        self.step_obs, reward_real, done_step, info_step = self.env.step(redisp_act)
+        assert not done_simulate, f"simulate is done, this should not be"
+        assert not done_step, f"step is done, this should not be"
+        assert not info_simu["exception"]
+        assert not info_step["exception"]
+        assert abs(reward_sim - reward_real) <= 1e-7
         # Test observations are the same
         if self.sim_obs != self.step_obs:
             diff_, attr_diff = self.sim_obs.where_different(self.step_obs)
@@ -2817,20 +2837,25 @@ def test_multi_simulate_last_change_bus(self):
         change_bus_act = self.env.action_space(
             {
                 "change_bus": {
-                    "loads_id": [1],
-                    "generators_ids": [1],
-                    "lines_or_id": [1],
+                    # "loads_id": [1],
+                    # "generators_ids": [1],
+                    # "lines_or_id": [1],
                     "lines_ex_id": [1],
                 }
             }
         )
         actions.append(change_bus_act)
-
         # Simulate all actions
         for act in actions:
-            self.sim_obs, _, _, _ = self.obs.simulate(act)
+            self.sim_obs, sim_r, sim_d, sim_i = self.obs.simulate(act)
         # Step with last action
-        self.step_obs, _, _, _ = self.env.step(actions[-1])
+        self.step_obs, step_r, step_d, step_i = self.env.step(actions[-1])
+        assert not sim_d, f"simulate is done, this should not be"
+        assert not step_d, f"step is done, this should not be"
+        assert not sim_i["exception"]
+        assert not step_i["exception"]
+        assert abs(sim_r - step_r) <= 1e-7
+        
         # Test observations are the same
         if self.sim_obs != self.step_obs:
             diff_, attr_diff = self.sim_obs.where_different(self.step_obs)
@@ -2850,9 +2875,9 @@ def test_multi_simulate_last_set_bus(self):
         set_bus_act = self.env.action_space(
             {
                 "set_bus": {
-                    "loads_id": [(1, new_load_bus)],
-                    "generators_ids": [(1, new_gen_bus)],
-                    "lines_or_id": [(1, new_lor_bus)],
+                    # "loads_id": [(1, new_load_bus)],
+                    # "generators_ids": [(1, new_gen_bus)],
+                    # "lines_or_id": [(1, new_lor_bus)],
                     "lines_ex_id": [(1, new_lex_bus)],
                 }
             }
@@ -2861,9 +2886,14 @@ def test_multi_simulate_last_set_bus(self):
 
         # Simulate all actions
         for act in actions:
-            self.sim_obs, _, _, _ = self.obs.simulate(act)
+            self.sim_obs, sim_r, sim_d, sim_i = self.obs.simulate(act)
         # Step with last action
-        self.step_obs, _, _, _ = self.env.step(actions[-1])
+        self.step_obs, step_r, step_d, step_i = self.env.step(actions[-1])
+        assert not sim_d, f"simulate is done, this should not be"
+        assert not step_d, f"step is done, this should not be"
+        assert not sim_i["exception"]
+        assert not step_i["exception"]
+        assert abs(sim_r - step_r) <= 1e-7
         # Test observations are the same
         if self.sim_obs != self.step_obs:
             diff_, attr_diff = self.sim_obs.where_different(self.step_obs)

grid2op/tests/test_Rules.py

@@ -10,6 +10,7 @@
 import warnings
 import unittest
 
+from grid2op.Observation.baseObservation import BaseObservation
 from grid2op.tests.helper_path_test import *
 
 import grid2op
@@ -684,105 +685,138 @@ def setUp(self):
             warnings.filterwarnings("ignore")
             self.params = Parameters()
             self.env = grid2op.make("rte_case5_example", test=True, param=self.params, _add_to_name=type(self).__name__)
-
+        self.env_or_obs = self.env
+        
     def tearDown(self):
         self.env.close()
 
+    def _aux_do_act(self, act):
+        if isinstance(self.env_or_obs, Environment):
+            _, _, _, info = self.env_or_obs.step(act)
+        elif isinstance(self.env_or_obs, BaseObservation):
+            _, _, _, info = self.env_or_obs.simulate(act)
+        else:
+            raise RuntimeError(f"Test not implemented for {type(self.env_or_obs)}")
+        return info
+    
+    def _aux_change_par(self, max_sub_changed):
+        if isinstance(self.env_or_obs, Environment):
+            self.env_or_obs._parameters.MAX_SUB_CHANGED = max_sub_changed
+        elif isinstance(self.env_or_obs, BaseObservation):
+            self.env_or_obs._obs_env._parameters.MAX_SUB_CHANGED = max_sub_changed
+        else:
+            raise RuntimeError(f"Test not implemented for {type(self.env_or_obs)}")
+        
     def test_setbus_line_no_sub_allowed_is_illegal(self):
         # Set 0 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 0
+        self._aux_change_par(0)
         # Make a setbus
         LINE_ID = 4
         bus_action = self.env.action_space({"set_bus": {"lines_ex_id": [(LINE_ID, 2)]}})
         # Make sure its illegal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == True
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == True
 
     def test_two_setbus_line_one_sub_allowed_is_illegal(self):
         # Set 1 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 1
+        self._aux_change_par(1)
         # Make a double setbus
         LINE1_ID = 4
         LINE2_ID = 5
         bus_action = self.env.action_space(
             {"set_bus": {"lines_ex_id": [(LINE1_ID, 2), (LINE2_ID, 2)]}}
         )
         # Make sure its illegal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == True
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == True
 
     def test_one_setbus_line_one_sub_allowed_is_legal(self):
         # Set 1 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 1
+        self._aux_change_par(1)
         # Make a setbus
         LINE1_ID = 4
         bus_action = self.env.action_space(
             {"set_bus": {"lines_ex_id": [(LINE1_ID, 2)]}}
         )
         # Make sure its legal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == False
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == False
 
     def test_two_setbus_line_two_sub_allowed_is_legal(self):
         # Set 2 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 2
+        self._aux_change_par(2)
         # Make a double setbus
         LINE1_ID = 4
         LINE2_ID = 5
         bus_action = self.env.action_space(
             {"set_bus": {"lines_ex_id": [(LINE1_ID, 2), (LINE2_ID, 2)]}}
         )
         # Make sure its legal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == False
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == False
 
     def test_changebus_line_no_sub_allowed_is_illegal(self):
         # Set 0 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 0
+        self._aux_change_par(0)
         # Make a changebus
         LINE_ID = 4
         bus_action = self.env.action_space({"change_bus": {"lines_ex_id": [LINE_ID]}})
         # Make sure its illegal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == True
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == True
 
     def test_changebus_line_one_sub_allowed_is_legal(self):
         # Set 1 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 1
+        self._aux_change_par(1)
         # Make a changebus
         LINE_ID = 4
         bus_action = self.env.action_space({"change_bus": {"lines_ex_id": [LINE_ID]}})
         # Make sure its legal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == False
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == False
 
     def test_changebus_two_line_one_sub_allowed_is_illegal(self):
         # Set 1 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 1
+        self._aux_change_par(1)
         # Make a changebus
         LINE1_ID = 4
         LINE2_ID = 5
         bus_action = self.env.action_space(
             {"change_bus": {"lines_ex_id": [LINE1_ID, LINE2_ID]}}
         )
         # Make sure its illegal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == True
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == True
 
     def test_changebus_two_line_two_sub_allowed_is_legal(self):
         # Set 2 allowed substation changes
-        self.env._parameters.MAX_SUB_CHANGED = 2
+        self._aux_change_par(2)
         # Make a changebus
         LINE1_ID = 4
         LINE2_ID = 5
         bus_action = self.env.action_space(
             {"change_bus": {"lines_ex_id": [LINE1_ID, LINE2_ID]}}
         )
         # Make sure its legal
-        _, _, _, i = self.env.step(bus_action)
-        assert i["is_illegal"] == False
+        info = self._aux_do_act(bus_action)
+        assert info["is_illegal"] == False
 
 
+class TestSubstationImpactLegalitySimulate(TestSubstationImpactLegality):
+    def setUp(self):
+        super().setUp()
+        self.env_or_obs = self.env.reset()
+        
+        
+class TestSubstationImpactLegalityForEnv(TestSubstationImpactLegality):
+    def setUp(self):
+        super().setUp()
+        obs = self.env.reset()
+        self.env_or_obs = obs.get_forecast_env()
+        self.env_or_obs.reset()
+# TODO TestSubstationImpactLegalitySimulate with chain simulate
+        
+        
 class TestLoadingFromInstance(unittest.TestCase):
     def test_correct(self):
         rules = AlwaysLegal()