fixing conflict with master [skip ci]

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

Author: BDonnot

CHANGELOG.rst

@@ -133,6 +133,16 @@ Native multi agents support:
 - [FIXED] deprecated call to `tostring_rgb` (replaced `tostring_argb`) in the env.render function.
 - [FIXED] warnings not properly issued in the AAA test when backend failed to call
   `can_handle_XXX` functions (*eg* `can_handle_more_than_2_busbar()` or `can_handle_detachment()`)
+- [FIXED] an issue with `obs.get_forecast_env` with changeNothing and DoNothingHandler time series
+- [FIXED] a bug in updating the shunt in PandaPowerBackend (depdending on pandas version)
+- [FIXED] a bug when action that reconnect loads, storage units or shunts are done
+  in the "obs.simulate" (results could depend from previous "obs.simulate" calls)
+- [FIXED] a bug in "obs.simulate" and "obs.get_forecast_env" : when a line was disconnected
+  and the user tried to reconnect it (without specifying on which bus) it could do something
+  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(...)` 
@@ -147,6 +157,7 @@ Native multi agents support:
   generators is not met (see `params.STOP_EP_IF_SLACK_BREAK_CONSTRAINTS`)
 - [ADDED] possibility to set the initial time stamp of the observation in the `env.reset`
   kwargs by using `env.reset(..., options={"init datetime": XXX})`
+- [ADDED] the `ChangeNothing` time series class now supports forecast
 - [IMPROVED] possibility to set the injections values with names
   to be consistent with other way to set the actions (*eg* set_bus)
 - [IMPROVED] error messages when creating an action which changes the injections
@@ -175,6 +186,7 @@ Native multi agents support:
 - [IMPROVED] the function `action.get_topological_impact(...)` has now a "caching" mechanism
   that allows not to recompute it over and over again (this is internal API please do not change 
   it... unless you know what you are doing)
+- [IMPROVED] `ForecastEnv` is now part of the public API.
 
 [1.10.5] - 2025-03-07
 ------------------------

getting_started/grid2op

@@ -881,6 +881,9 @@ def _assign_0_to_disco_el(self) -> None:
         Do not consider disconnected elements are modified for there active / reactive / voltage values
         """
         cls = type(self)
+        if not cls.detachment_is_allowed:
+            # is detachment is not allowed, this should not happen
+            return
         gen_changed = self.current_topo.changed[cls.gen_pos_topo_vect]
         gen_bus = self.current_topo.values[cls.gen_pos_topo_vect]
         self.prod_p.force_unchanged(gen_changed, gen_bus)

grid2op/Action/_backendAction.py

@@ -23,7 +23,7 @@
 from grid2op.typing_variables import DICT_ACT_TYPING
 from grid2op.dtypes import dt_int, dt_bool, dt_float
 from grid2op.Exceptions import *
-from grid2op.Space import GridObjects
+from grid2op.Space import GridObjects, GRID2OP_CURRENT_VERSION_STR
 
 # TODO time delay somewhere (eg action is implemented after xxx timestep, and not at the time where it's proposed)
 
@@ -471,10 +471,10 @@ def __init__(self, _names_chronics_to_backend: Optional[Dict[Literal["loads", "p
         # shunts
         if cls.shunts_data_available:
             self.shunt_p = np.full(
-                shape=cls.n_shunt, fill_value=np.NaN, dtype=dt_float
+                shape=cls.n_shunt, fill_value=np.nan, dtype=dt_float
             )
             self.shunt_q = np.full(
-                shape=cls.n_shunt, fill_value=np.NaN, dtype=dt_float
+                shape=cls.n_shunt, fill_value=np.nan, dtype=dt_float
             )
             self.shunt_bus = np.full(shape=cls.n_shunt, fill_value=0, dtype=dt_int)
         else:
@@ -1805,8 +1805,8 @@ def reset(self):
 
         # shunts
         if type(self).shunts_data_available:
-            self.shunt_p[:] = np.NaN
-            self.shunt_q[:] = np.NaN
+            self.shunt_p[:] = np.nan
+            self.shunt_q[:] = np.nan
             self.shunt_bus[:] = 0
 
         # alarm
@@ -2425,7 +2425,7 @@ def _digest_storage(self, dict_):
             except IllegalAction as exc_:
                 cls = type(self)
                 # only raise the error if I am not in compat mode
-                if cls.glop_version == grid2op.__version__:
+                if cls.glop_version == GRID2OP_CURRENT_VERSION_STR:
                     raise exc_
                 else:
                     # TODO be more specific on the version
@@ -2439,7 +2439,7 @@ def _digest_curtailment(self, dict_):
             except IllegalAction as exc_:
                 cls = type(self)
                 # only raise the error if I am not in compat mode
-                if cls.glop_version == grid2op.__version__:
+                if cls.glop_version == GRID2OP_CURRENT_VERSION_STR:
                     raise exc_
                 else:
                     # TODO be more specific on the version
@@ -3990,7 +3990,7 @@ def _aux_effect_on_load(self, load_id):
             )
         if load_id < 0:
             raise Grid2OpException(f"`load_id` should be positive.")
-        res = {"new_p": np.NaN, "new_q": np.NaN, "change_bus": False, "set_bus": 0}
+        res = {"new_p": np.nan, "new_q": np.nan, "change_bus": False, "set_bus": 0}
         if "load_p" in self._dict_inj:
             res["new_p"] = self._dict_inj["load_p"][load_id]
         if "load_q" in self._dict_inj:
@@ -4008,7 +4008,7 @@ def _aux_effect_on_gen(self, gen_id):
             )
         if gen_id < 0:
             raise Grid2OpException(f"`gen_id` should be positive.")
-        res = {"new_p": np.NaN, "new_v": np.NaN, "set_bus": 0, "change_bus": False}
+        res = {"new_p": np.nan, "new_v": np.nan, "set_bus": 0, "change_bus": False}
         if "prod_p" in self._dict_inj:
             res["new_p"] = self._dict_inj["prod_p"][gen_id]
         if "prod_v" in self._dict_inj:
@@ -4051,7 +4051,7 @@ def _aux_effect_on_storage(self, storage_id):
             )
         if storage_id < 0:
             raise Grid2OpException(f"`storage_id` should be positive.")
-        res = {"power": np.NaN, "set_bus": 0, "change_bus": False}
+        res = {"power": np.nan, "set_bus": 0, "change_bus": False}
         my_id = self.storage_pos_topo_vect[storage_id]
         res["change_bus"] = self._change_bus_vect[my_id]
         res["set_bus"] = self._set_topo_vect[my_id]
@@ -4266,7 +4266,7 @@ def get_load_modif(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray
             New bus of the loads, affected with "change_bus" command
         """
         cls = type(self)
-        load_p = np.full(cls.n_load, fill_value=np.NaN, dtype=dt_float)
+        load_p = np.full(cls.n_load, fill_value=np.nan, dtype=dt_float)
         if "load_p" in self._dict_inj:
             load_p[:] = self._dict_inj["load_p"]
         load_q = 1.0 * load_p
@@ -4295,7 +4295,7 @@ def get_gen_modif(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
 
         """
         cls = type(self)
-        gen_p = np.full(cls.n_gen, fill_value=np.NaN, dtype=dt_float)
+        gen_p = np.full(cls.n_gen, fill_value=np.nan, dtype=dt_float)
         if "prod_p" in self._dict_inj:
             gen_p[:] = self._dict_inj["prod_p"]
         gen_v = 1.0 * gen_p

grid2op/Action/baseAction.py

@@ -1517,7 +1517,7 @@ def _aux_get_back_to_ref_state_curtail(self, res, obs):
                 )
                 return
 
-            curtail = np.full(obs.n_gen, fill_value=np.NaN)
+            curtail = np.full(obs.n_gen, fill_value=np.nan)
             curtail[is_curtailed] = 1.0
             act = self.actionClass()
             act.curtail = curtail

grid2op/Action/serializableActionSpace.py

@@ -61,7 +61,7 @@ def act(self, observation: BaseObservation, reward: float, done : bool=False) ->
         self.tested_action = self._get_tested_action(observation)
         if len(self.tested_action) > 1:
             self.resulting_rewards = np.full(
-                shape=len(self.tested_action), fill_value=np.NaN, dtype=dt_float
+                shape=len(self.tested_action), fill_value=np.nan, dtype=dt_float
             )
             for i, action in enumerate(self.tested_action):
                 (

grid2op/Agent/greedyAgent.py

@@ -15,7 +15,7 @@
 from abc import ABC, abstractmethod
 import numpy as np
 import pandas as pd
-from typing import Tuple, Optional, Any, Dict, Union
+from typing import Tuple, Optional, Any, Dict, Type, Union
 
 try:
     from typing import Self
@@ -36,6 +36,9 @@
     Grid2OpException,
 )
 from grid2op.Space import GridObjects, ElTypeInfo, DEFAULT_N_BUSBAR_PER_SUB, DEFAULT_ALLOW_DETACHMENT
+import grid2op.Observation  # for type hints
+import grid2op.Action  # for type hints
+import grid2op.Action._BackendAction  # for type hints
 
 
 # TODO method to get V and theta at each bus, could be in the same shape as check_kirchoff
@@ -116,8 +119,8 @@ class Backend(GridObjects, ABC):
     IS_BK_CONVERTER : bool = False
 
     # action to set me
-    my_bk_act_class : "Optional[grid2op.Action._backendAction._BackendAction]" = None
-    _complete_action_class : "Optional[grid2op.Action.CompleteAction]" = None
+    my_bk_act_class : "Optional[Type[grid2op.Action._BackendAction._BackendAction]]" = None
+    _complete_action_class : "Optional[Type[grid2op.Action.CompleteAction]]" = None
 
     ERR_INIT_POWERFLOW : str = "Power cannot be computed on the first time step, please check your data."
     ERR_DETACHMENT : str = ("One or more {} were isolated from the grid "
@@ -1906,8 +1909,8 @@ def get_action_to_set(self) -> "grid2op.Action.CompleteAction":
                 sh_conn = bus_s > 0
                 p_s[sh_conn] *= (self._sh_vnkv[sh_conn] / sh_v[sh_conn]) ** 2
                 q_s[sh_conn] *= (self._sh_vnkv[sh_conn] / sh_v[sh_conn]) ** 2
-                p_s[bus_s == -1] = np.NaN
-                q_s[bus_s == -1] = np.NaN
+                p_s[bus_s == -1] = np.nan
+                q_s[bus_s == -1] = np.nan
                 dict_["shunt"]["shunt_p"] = p_s
                 dict_["shunt"]["shunt_q"] = q_s
 
@@ -1920,7 +1923,7 @@ def get_action_to_set(self) -> "grid2op.Action.CompleteAction":
 
     def update_from_obs(self,
                         obs: "grid2op.Observation.CompleteObservation",
-                        force_update: Optional[bool]=False):
+                        force_update: Optional[bool]=False) -> "grid2op.Action._BackendAction._BackendAction":
         """
         Takes an observation as input and update the internal state of `self` to match the state of the backend
         that produced this observation.
@@ -1954,23 +1957,23 @@ def update_from_obs(self,
             )
 
         cls = type(self)
-        backend_action = cls.my_bk_act_class()
+        backend_action : "grid2op.Action._BackendAction._BackendAction" = cls.my_bk_act_class()        
         act = cls._complete_action_class()
         line_status = self._aux_get_line_status_to_set(obs.line_status)
         # skip the action part and update directly the backend action !
         dict_ = {
             "set_bus": obs.topo_vect,
             "set_line_status": line_status,
             "injection": {
-                "prod_p": obs.prod_p,
-                "prod_v": obs.prod_v,
-                "load_p": obs.load_p,
-                "load_q": obs.load_q,
+                "prod_p": obs._get_gen_p_for_forecasts(),
+                "prod_v": obs._get_gen_v_for_forecasts(),
+                "load_p": obs._get_load_p_for_forecasts(),
+                "load_q": obs._get_load_q_for_forecasts(),
             },
         }
 
         if cls.shunts_data_available and type(obs).shunts_data_available:
-            if cls.n_shunt > 0 and "_shunt_bus" not in type(obs).attr_list_set:
+            if cls.n_shunt > 0 and "_shunt_bus" not in (type(obs).attr_list_set | set(type(obs).attr_list_json)):
                 raise BackendError(
                     "Impossible to set the backend to the state given by the observation: shunts data "
                     "are not present in the observation."
@@ -1982,15 +1985,17 @@ def update_from_obs(self,
                 mults = (self._sh_vnkv / obs._shunt_v) ** 2
                 sh_p = obs._shunt_p * mults
                 sh_q = obs._shunt_q * mults
-                sh_p[~shunt_co] = np.NaN
-                sh_q[~shunt_co] = np.NaN
+                sh_p[~shunt_co] = np.nan
+                sh_q[~shunt_co] = np.nan
                 dict_["shunt"]["shunt_p"] = sh_p
                 dict_["shunt"]["shunt_q"] = sh_q
         elif cls.shunts_data_available and not type(obs).shunts_data_available:
             warnings.warn("Backend supports shunt but not the observation. This behaviour is non standard.")
         act.update(dict_)
         backend_action += act
         self.apply_action(backend_action)
+        backend_action.reset()  # already processed by the backend
+        return backend_action
 
     def assert_grid_correct(self, _local_dir_cls=None) -> None:
         """

grid2op/Backend/backend.py

@@ -351,7 +351,7 @@ def get_topo_vect(self) -> np.ndarray:
 
         Function is verbose (~40 lines of code), but pretty straightforward.
         """
-        res = np.full(self.dim_topo, fill_value=np.NaN, dtype=dt_int)
+        res = np.full(self.dim_topo, fill_value=np.nan, dtype=dt_int)
 
         line_status = self.get_line_status()