fixing some issues

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

Author: BDonnot

CHANGELOG.rst

@@ -142,6 +142,7 @@ Native multi agents support:
   different than "env.step" (with the same action)
 - [FIXED] a powerflow is run when the environment is first created even before the initial "env.step"
   function is called. This is to ensure proper behaviour if env is used without being reset.
+- [FIXED] no error was catched if the backend could not properly apply the action sent by the environment.
 - [ADDED] possibility to set the "thermal limits" when calling `env.reset(..., options={"thermal limit": xxx})`
 - [ADDED] possibility to retrieve some structural information about elements with
   with `gridobj.get_line_info(...)`, `gridobj.get_load_info(...)`, `gridobj.get_gen_info(...)` 

grid2op/Environment/_obsEnv.py

@@ -447,6 +447,8 @@ def reset(self):
                            "environment that cannot be copied.")
         super().reset()
         self.current_obs = self.current_obs_init
+        # force the checking of the rules for the action
+        self._called_from_reset = False  
 
     def simulate(self, action : "grid2op.Action.BaseAction") -> Tuple["grid2op.Observation.BaseObservation", float, bool, STEP_INFO_TYPING]:
         """

grid2op/Environment/baseEnv.py

@@ -44,7 +44,8 @@
                                 SomeGeneratorAbovePmax,
                                 SomeGeneratorBelowPmin,
                                 SomeGeneratorAboveRampmax, 
-                                SomeGeneratorBelowRampmin)
+                                SomeGeneratorBelowRampmin,
+                                BackendError)
 from grid2op.Parameters import Parameters
 from grid2op.Reward import BaseReward, RewardHelper
 from grid2op.Opponent import OpponentSpace, NeverAttackBudget, BaseOpponent
@@ -671,6 +672,9 @@ def __init__(
         self._previous_conn_state = None
         self._cst_prev_state_at_init = None
 
+        # 1.11: do not check rules if first observation
+        self._called_from_reset = True
+        
     @property
     def highres_sim_counter(self):
         return self._highres_sim_counter
@@ -994,6 +998,9 @@ def _custom_deepcopy_for_copy(self, new_obj, dict_=None):
         new_obj._previous_conn_state = copy.deepcopy(self._previous_conn_state)
         new_obj._cst_prev_state_at_init = self._cst_prev_state_at_init  # no need to deep copy this
 
+        
+        new_obj._called_from_reset = self._called_from_reset
+        
     def get_path_env(self):
         """
         Get the path that allows to create this environment.
@@ -1550,6 +1557,7 @@ def reset(self,
                                    f"can be used.")
 
         self.__is_init = True
+        self._called_from_reset = True
         # current = None is an indicator that this is the first step of the environment
         # so don't change the setting of current_obs = None unless you are willing to change that
         self.current_obs = None
@@ -3550,7 +3558,8 @@ def step(self, action: BaseAction) -> Tuple[BaseObservation,
             # and this regardless of the 
             _ = action.get_topological_impact(powerline_status, _store_in_cache=True, _read_from_cache=False)
 
-            if self._last_obs is not None:
+            if not self._called_from_reset:
+                # avoid checking this at first environment "step" which is a "reset"
                 is_legal, reason = self._game_rules(action=action, env=self)
             else:
                 is_legal = True
@@ -3634,6 +3643,10 @@ def step(self, action: BaseAction) -> Tuple[BaseObservation,
                     is_done = True
                     # TODO in this case: cancel the topological action of the agent
                     # and continue instead of "game over"
+                except BackendError as exc_:
+                    has_error = True
+                    except_.append(exc_)
+                    is_done = True
                 self._time_apply_act += time.perf_counter() - beg_
 
                 # now it's time to run the powerflow properly

grid2op/Environment/environment.py

@@ -490,6 +490,7 @@ def _init_backend(
         # thermal limits are set AFTER this initial step
         _no_overflow_disconnection = self._no_overflow_disconnection
         self._no_overflow_disconnection = True
+        self._last_obs = None
         *_, fail_to_start, info = self.step(do_nothing)
         self._no_overflow_disconnection = _no_overflow_disconnection
 
@@ -1336,6 +1337,7 @@ def reset(self,
         # process the "options" kwargs
         # (if there is an init state then I need to process it to remove the 
         # some keys)
+        self._called_from_reset = False
         self._max_step = None
         method = "combine"
         init_state = None
@@ -1416,6 +1418,8 @@ def reset(self,
                 self._init_obs = None
                 if init_dt is not None:
                     self.chronics_handler.set_current_datetime(init_dt) 
+                self._last_obs = None  # properly initialize the last observation
+                self._called_from_reset = True
                 self.step(self.action_space())
             elif skip_ts == 2:
                 self.fast_forward_chronics(1, init_dt)
@@ -1436,6 +1440,9 @@ def reset(self,
         # and reset also the "simulated env" in the observation space
         self._observation_space.reset(self)
         self._observation_space.set_real_env_kwargs(self)
+        self._called_from_reset = False        
+        # force the first observation to be generated properly
+        self._last_obs = None
         return self.get_obs()
 
     def render(self, mode="rgb_array"):

grid2op/Observation/observationSpace.py

@@ -495,8 +495,8 @@ def _custom_deepcopy_for_copy(self, new_obj, env=None):
 
         # real env kwargs, these is a "pointer" anyway
         if env is not None:
-            from grid2op.Environment import Environment
-            new_obj._real_env_kwargs = Environment.get_kwargs(env, False, False)
+            new_obj._real_env_kwargs = {}
+            new_obj.set_real_env_kwargs(env)
         else:
             new_obj._real_env_kwargs = self._real_env_kwargs
         new_obj._observation_bk_class = self._observation_bk_class

grid2op/tests/test_AlarmFeature.py

@@ -217,7 +217,7 @@ def test_alarm_obs_whenalarm(self):
         obs = self.env.reset()
         nb_th = 3
         assert abs(self.env._attention_budget._current_budget - nb_th) <= 1e-6
-        assert abs(obs.attention_budget - nb_th) <= 1e-6
+        assert abs(obs.attention_budget - nb_th) <= 1e-6, f"{obs.attention_budget} vs {nb_th}"
         assert obs.time_since_last_alarm == -1
         assert np.all(obs.last_alarm == [-1, -1, -1])
 

grid2op/tests/test_MaskedEnvironment.py

@@ -221,8 +221,10 @@ def test_gym_multidiscrete(self):
         env_gym_in.reset()
         env_gym_out.reset()
         act = env_gym_in.action_space.sample()
-        act[:] = 0
-        self._aux_run_envs(act, env_gym_in, env_gym_out)
+        act[:] = 0  # this is not the do nothing action...
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore")
+            self._aux_run_envs(act, env_gym_in, env_gym_out)
 
 
 if __name__ == "__main__":

grid2op/tests/test_basic_env_ls.py

@@ -47,7 +47,8 @@ def setUp(self) -> None:
             self.env = grid2op.make("l2rpn_case14_sandbox",
                                     test=True,
                                     _add_to_name=type(self).__name__,
-                                    backend=LightSimBackend())
+                                    backend=LightSimBackend(),
+                                    allow_detachment=False)
         self.line_id = 3
         th_lim = self.env.get_thermal_limit() * 2.  # avoid all problem in general
         th_lim[self.line_id] /= 10.  # make sure to get trouble in line 3
@@ -169,6 +170,9 @@ def test_backward_compatibility(self):
             "1.9.8",
             "1.10.0",
             "1.10.1",
+            "1.10.2",
+            "1.10.3",
+            "1.10.4",
         ]
         # first check a normal run
         curr_version = "test_version"
@@ -275,12 +279,12 @@ def _aux_backward(self, base_path, g2op_version_txt, g2op_version):
             if g2op_ver <= version.parse("1.4.0"):
                 assert (
                     EpisodeData.get_grid2op_version(full_episode_path) == "<=1.4.0"
-                ), "wrong grid2op version stored (grid2op version <= 1.4.0)"
+                ), f"wrong grid2op version stored (grid2op version <= 1.4.0) stored {EpisodeData.get_grid2op_version(full_episode_path)} vs '<=1.4.0'"
             elif g2op_version == "test_version":
                 assert (
                     EpisodeData.get_grid2op_version(full_episode_path)
                     == grid2op.__version__
-                ), "wrong grid2op version stored (test_version)"
+                ), f"wrong grid2op version stored (test_version) : {EpisodeData.get_grid2op_version(full_episode_path)} vs {grid2op.__version__}"
             else:
                 assert (
                     EpisodeData.get_grid2op_version(full_episode_path) == g2op_version
@@ -342,10 +346,10 @@ def test_gym_multidiscrete(self):
         env_gym = GymEnv(self.env)
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore")
-            env_gym.action_space = MultiDiscreteActSpace(self.env.action_space)
+            env_gym.action_space = MultiDiscreteActSpace(self.env.action_space, attr_to_keep=["set_line_status"])
         env_gym.reset()
         act = env_gym.action_space.sample()
-        act[:] = 0
+        act[:] = 1  # apparently this is "do nothing"
         self._aux_run_envs(act, env_gym)