LightSim2Grid 0.8.1__tar.gz → 0.8.1.dev0__tar.gz

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0/LightSim2Grid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightSim2Grid
-Version: 0.8.1
+Version: 0.8.1.dev0
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/BDonnot/lightsim2grid/
 Author: Benjamin Donnot
@@ -278,7 +278,7 @@ For example: `export PATH_NICSLU=/home/user/Documents/cktso`
 
 #### Enable 03 optimization
 By default, at least on ubuntu, only the "-O2" compiler flags is used. To use the O3 optimization flag, you need
-to specify the `__O3_OPTIM` environment variable: `set __O3_OPTIM=1` before the compilation (so before
+to specify the `__COMPLILE_O3` environment variable: `set __COMPLILE_O3=1` before the compilation (so before
 `python3 setup.py build` or `python -m pip install -e .`)
 
 This compilation argument will increase the compilation time, but will make the package faster.

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/LightSim2Grid.egg-info/SOURCES.txt

@@ -483,7 +483,6 @@ lightsim2grid/physical_law_checker.py
 lightsim2grid/securityAnalysis.py
 lightsim2grid/timeSerie.py
 lightsim2grid/_utils/__init__.py
-lightsim2grid/compilation_options/__init__.py
 lightsim2grid/elements/__init__.py
 lightsim2grid/gridmodel/__init__.py
 lightsim2grid/gridmodel/_aux_add_dc_line.py
@@ -501,8 +500,6 @@ lightsim2grid/gridmodel/from_pypowsybl.py
 lightsim2grid/gridmodel/initGridModel.py
 lightsim2grid/newtonpf/__init__.py
 lightsim2grid/newtonpf/newtonpf.py
-lightsim2grid/rewards/__init__.py
-lightsim2grid/rewards/n1ContingencyReward.py
 lightsim2grid/solver/__init__.py
 src/BaseConstants.cpp
 src/BaseConstants.h

{LightSim2Grid-0.8.1/LightSim2Grid.egg-info → LightSim2Grid-0.8.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightSim2Grid
-Version: 0.8.1
+Version: 0.8.1.dev0
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/BDonnot/lightsim2grid/
 Author: Benjamin Donnot
@@ -278,7 +278,7 @@ For example: `export PATH_NICSLU=/home/user/Documents/cktso`
 
 #### Enable 03 optimization
 By default, at least on ubuntu, only the "-O2" compiler flags is used. To use the O3 optimization flag, you need
-to specify the `__O3_OPTIM` environment variable: `set __O3_OPTIM=1` before the compilation (so before
+to specify the `__COMPLILE_O3` environment variable: `set __COMPLILE_O3=1` before the compilation (so before
 `python3 setup.py build` or `python -m pip install -e .`)
 
 This compilation argument will increase the compilation time, but will make the package faster.

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/README.md

@@ -222,7 +222,7 @@ For example: `export PATH_NICSLU=/home/user/Documents/cktso`
 
 #### Enable 03 optimization
 By default, at least on ubuntu, only the "-O2" compiler flags is used. To use the O3 optimization flag, you need
-to specify the `__O3_OPTIM` environment variable: `set __O3_OPTIM=1` before the compilation (so before
+to specify the `__COMPLILE_O3` environment variable: `set __COMPLILE_O3=1` before the compilation (so before
 `python3 setup.py build` or `python -m pip install -e .`)
 
 This compilation argument will increase the compilation time, but will make the package faster.

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/__init__.py

@@ -1,13 +1,13 @@
-# Copyright (c) 2020-2024, RTE (https://www.rte-france.com)
+# Copyright (c) 2020, RTE (https://www.rte-france.com)
 # See AUTHORS.txt
 # This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
 # If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
 # you can obtain one at http://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
-__version__ = "0.8.1"
+__version__ = "0.8.1.dev0"
 
-__all__ = ["newtonpf", "SolverType", "ErrorType", "solver", "compilation_options"]
+__all__ = ["newtonpf", "SolverType", "ErrorType", "solver"]
 
 # import directly from c++ module
 from lightsim2grid.solver import SolverType
@@ -46,11 +46,3 @@ except ImportError as exc_:
     # grid2op is not installed, the SecurtiyAnalysis module will not be available
     pass
     print(f"ContingencyAnalysis import error: {exc_}")
-    
-try:
-    from lightsim2grid.rewards import *
-    __all__.append("rewards")
-except ImportError as exc_:
-    # grid2op is not installed, the SecurtiyAnalysis module will not be available
-    pass
-    print(f"rewards import error: {exc_}")

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/contingencyAnalysis.py

@@ -6,25 +6,21 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
-__all__ = ["ContingencyAnalysisCPP"]
+__all__ = ["ContingencyAnalysisCPP", "ContingencyAnalysis",
+           # deprecated
+           "SecurityAnalysisCPP", "SecurityAnalysis",
+           ]
 
 import copy
 import numpy as np
 from collections.abc import Iterable
 
+from lightsim2grid.lightSimBackend import LightSimBackend
 from lightsim2grid.solver import SolverType
 from lightsim2grid_cpp import ContingencyAnalysisCPP
 
-try:
-    from lightsim2grid.lightSimBackend import LightSimBackend
-    __all__.append("ContingencyAnalysis")
-    GRID2OP_INSTALLED = True
-except ImportError as exc_:
-    # grid2op is not installed
-    GRID2OP_INSTALLED = False
 
-
-class __ContingencyAnalysis(object):
+class ContingencyAnalysis(object):
     """
     This class allows to perform a "security analysis" from a given grid state.
 
@@ -80,26 +76,10 @@ class __ContingencyAnalysis(object):
     STR_TYPES = (str, np.str_)  # np.str deprecated in numpy 1.20 and earlier versions not supported anyway
         
     def __init__(self, grid2op_env):
-        if not GRID2OP_INSTALLED:
-            raise RuntimeError("Impossible to use the python wrapper `ContingencyAnalysis` "
-                               "when grid2op is not installed. Please fall back to the "
-                               "c++ version (available in python) with:\n"
-                               "\tfrom lightsim2grid.contingencyAnalysis import ContingencyAnalysisCPP\n"
-                               "and refer to the appropriate documentation.")
-        from grid2op.Environment import Environment
-        if isinstance(grid2op_env, Environment):    
-            if not isinstance(grid2op_env.backend, LightSimBackend):
-                raise RuntimeError("This class only works with LightSimBackend")
-            self._ls_backend = grid2op_env.backend.copy()
-        elif isinstance(grid2op_env, LightSimBackend):
-            if hasattr(grid2op_env, "_is_loaded") and not grid2op_env._is_loaded:
-                raise RuntimeError("Impossible to init a `ContingencyAnalysis` "
-                                   "with a backend that has not been initialized.")
-            self._ls_backend = grid2op_env.copy()
-        else:
-            raise RuntimeError("`ContingencyAnalysis` can only be created "
-                               "with a grid2op `Environment` or a `LightSimBackend`")
-        self.computer = ContingencyAnalysisCPP(self._ls_backend._grid)
+        if not isinstance(grid2op_env.backend, LightSimBackend):
+            raise RuntimeError("This class only works with LightSimBackend")
+        self.grid2op_env = grid2op_env.copy()
+        self.computer = ContingencyAnalysisCPP(self.grid2op_env.backend._grid)
         self._contingency_order = {}  # key: contingency (as tuple), value: order in which it is entered
         self._all_contingencies = []
         self.__computed = False
@@ -120,29 +100,16 @@ class __ContingencyAnalysis(object):
         raise RuntimeError("Impossible to add new topologies like this. Please use `add_single_contingency` "
                            "or `add_multiple_contingencies`.")
 
-    # TODO implement that !
-    def __update_grid(self, backend_act):
-        self.clear(with_contlist=False)
-        self._ls_backend.apply_action(backend_act)
-        # run the powerflow
-        self._ls_backend.runpf()
-        # update the computer
-        # self.computer = ContingencyAnalysisCPP(self._ls_backend._grid)
-        # self.computer.update_grid(...)  # not implemented
-        
-    def clear(self, with_contlist=True):
+    def clear(self):
         """
         Clear the list of contingencies to simulate
         """
+        self.computer.clear()
+        self._contingency_order = {}
         self.__computed = False
         self._vs = None
         self._ampss = None
-        if with_contlist:
-            self.computer.clear()
-            self._contingency_order = {}
-            self._all_contingencies = []
-        else:
-            self.computer.clear_results_only()
+        self._all_contingencies = []
 
     def _single_cont_to_li_int(self, single_cont):
         li_disc = []
@@ -151,7 +118,7 @@ class __ContingencyAnalysis(object):
 
         for stuff in single_cont:
             if isinstance(stuff, type(self).STR_TYPES):
-                stuff = np.where(type(self._ls_backend).name_line == stuff)
+                stuff = np.where(self.grid2op_env.name_line == stuff)
                 stuff = stuff[0]
                 if stuff.size == 0:
                     # name is not found
@@ -266,7 +233,7 @@ class __ContingencyAnalysis(object):
             for single_cont_id in range(env.n_line):
                 self.add_single_contingency(single_cont_id)
         """
-        for single_cont_id in range(type(self._ls_backend).n_line):
+        for single_cont_id in range(self.grid2op_env.n_line):
             self.add_single_contingency(single_cont_id)
 
     def get_flows(self, *args):
@@ -335,10 +302,10 @@ class __ContingencyAnalysis(object):
             been entered. Please use `get_flows()` method for easier reading back of the results
 
         """
-        v_init = 1. * self._ls_backend.V
+        v_init = self.grid2op_env.backend.V
         self.computer.compute(v_init,
-                              self._ls_backend.max_it,
-                              self._ls_backend.tol)
+                              self.grid2op_env.backend.max_it,
+                              self.grid2op_env.backend.tol)
         self._vs = self.computer.get_voltages()
         self.__computed = True
         return self._vs
@@ -375,10 +342,6 @@ class __ContingencyAnalysis(object):
 
     def close(self):
         """permanently close the object"""
-        self._ls_backend.close()
+        self.grid2op_env.close()
         self.clear()
         self.computer.close()
-        
-        
-if GRID2OP_INSTALLED:
-    ContingencyAnalysis = __ContingencyAnalysis

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/gridmodel/from_pypowsybl.py

@@ -78,8 +78,8 @@ def init(net : pypo.network,
     # to handle encoding in 32 bits and overflow when "splitting" the Q values among 
     min_q = df_gen["min_q"].values.astype(np.float32)
     max_q = df_gen["max_q"].values.astype(np.float32)
-    min_q[~np.isfinite(min_q)] = np.finfo(np.float32).min * 1e-4 + 1.
-    max_q[~np.isfinite(max_q)] = np.finfo(np.float32).max * 1e-4 - 1.
+    min_q[~np.isfinite(min_q)] = np.finfo(np.float32).min * 0.5 + 1.
+    max_q[~np.isfinite(max_q)] = np.finfo(np.float32).max * 0.5 - 1.
     gen_bus, gen_disco = _aux_get_bus(bus_df, df_gen)
     model.init_generators_full(df_gen["target_p"].values,
                                df_gen["target_v"].values / voltage_levels.loc[df_gen["voltage_level_id"].values]["nominal_v"].values,

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/gridmodel/initGridModel.py

@@ -15,9 +15,6 @@ __all__ = ["init", "GridModel"]
 import numpy as np
 from numbers import Number
 import warnings
-
-import pandapower
-import lightsim2grid
 from lightsim2grid_cpp import GridModel, PandaPowerConverter
 from lightsim2grid.gridmodel._aux_add_sgen import _aux_add_sgen
 from lightsim2grid.gridmodel._aux_add_load import _aux_add_load
@@ -31,7 +28,7 @@ from lightsim2grid.gridmodel._aux_add_storage import _aux_add_storage
 from lightsim2grid.gridmodel._aux_add_dc_line import _aux_add_dc_line
 
 
-def init(pp_net: "pandapower.auxiliary.pandapowerNet") -> GridModel:
+def init(pp_net):
     """
     Convert a pandapower network as input into a GridModel.
 
@@ -56,7 +53,7 @@ def init(pp_net: "pandapower.auxiliary.pandapowerNet") -> GridModel:
 
     Parameters
     ----------
-    pp_net: :class:`pandapower.auxiliary.pandapowerNet`
+    pp_net: :class:`pandapower.grid`
         The initial pandapower network you want to convert
 
     Returns

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/lightSimBackend.py

@@ -6,21 +6,13 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
-import os
 import copy
-from typing import Tuple, Optional, Any, Dict, Union
-try:
-    from typing import Self
-except ImportError:
-    # python version is probably bellow 3.11
-    from typing_extensions import Self
-    
+from typing import Optional, Union
 import warnings
 import numpy as np
 import pandas as pd
 import time
 
-import grid2op
 from grid2op.Action import CompleteAction
 from grid2op.Backend import Backend
 from grid2op.Exceptions import BackendError
@@ -223,9 +215,9 @@ class LightSimBackend(Backend):
         # it takes only into account the time spend in the powerflow algorithm
         self.comp_time = 0.  
 
-        #: computation time of the powerflow
-        #: it takes into account everything in the gridmodel, including the mapping 
-        #: to the solver, building of Ybus and Sbus AND the time to solve the powerflow
+        # computation time of the powerflow
+        # it takes into account everything in the gridmodel, including the mapping 
+        # to the solver, building of Ybus and Sbus AND the time to solve the powerflow
         self.timer_gridmodel_xx_pf = 0.
         
         self._timer_postproc = 0.
@@ -255,7 +247,6 @@ class LightSimBackend(Backend):
         self._trafo_hv_res = None
         self._trafo_lv_res = None
         self._storage_res = None
-        self._reset_res_pointers()
         
     def _aux_init_super(self, 
                         detailed_infos_for_cascading_failures,
@@ -304,7 +295,7 @@ class LightSimBackend(Backend):
         self._turned_off_pv = True
         self._grid.turnedoff_pv()
 
-    def get_theta(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def get_theta(self):
         """
 
         Returns
@@ -352,7 +343,7 @@ class LightSimBackend(Backend):
         """
         return self._grid.get_solver_type(), self._grid.get_dc_solver_type()
         
-    def set_solver_type(self, solver_type: SolverType) -> None:
+    def set_solver_type(self, solver_type: SolverType):
         """
         Change the type of solver you want to use.
 
@@ -394,7 +385,7 @@ class LightSimBackend(Backend):
             raise BackendError(f"The solver type provided \"{solver_type}\" is not available on your system. Available"
                                f"solvers are {self.available_solvers}")
             
-    def set_solver_max_iter(self, max_iter: int) -> None:
+    def set_solver_max_iter(self, max_iter):
         """
         Set the maximum number of iteration the solver is allowed to perform.
 
@@ -427,7 +418,7 @@ class LightSimBackend(Backend):
             raise BackendError("max_iter should be a strictly positive integer (integer >= 1)")
         self.max_it = max_iter
 
-    def set_tol(self, new_tol: float) -> None:
+    def set_tol(self, new_tol):
         """
         Set the tolerance of the powerflow. This means that the powerflow will stop when the Kirchhoff's Circuit Laws
         are met up to a tolerance of "new_tol".
@@ -477,9 +468,7 @@ class LightSimBackend(Backend):
             else:
                 self._grid.change_solver(SolverType.SparseLU)
                 
-    def load_grid(self,
-                  path : Union[os.PathLike, str],
-                  filename : Optional[Union[os.PathLike, str]]=None) -> None: 
+    def load_grid(self, path=None, filename=None):    
         if hasattr(type(self), "can_handle_more_than_2_busbar"):
             # grid2op version >= 1.10.0 then we use this
             self.can_handle_more_than_2_busbar()
@@ -626,7 +615,6 @@ class LightSimBackend(Backend):
             self.name_line = np.concatenate((lor_sub.index, tor_sub.index))
             self.name_storage = np.array(batt_sub.index)
             self.name_shunt = np.array(sh_sub.index)
-            self.name_sub = np.array(buses_sub_id.index)
         
         if "reconnect_disco_gen" in loader_kwargs and loader_kwargs["reconnect_disco_gen"]:
             for el in self._grid.get_generators():
@@ -690,45 +678,11 @@ class LightSimBackend(Backend):
             self._grid._max_nb_bus_per_sub = self.n_busbar_per_sub
             
         self._grid.tell_solver_need_reset()
-    
-    def init_from_loaded_pandapower(self, pp_net):
-        if hasattr(type(self), "can_handle_more_than_2_busbar"):
-            type(self.init_pp_backend).n_busbar_per_sub = self.n_busbar_per_sub
-        self.init_pp_backend = pp_net.copy()
-        self._aux_init_pandapower()
-        
-        # handles redispatching
-        if type(pp_net).redispatching_unit_commitment_availble:
-            self.redispatching_unit_commitment_availble = True
-            for attr_nm in ["gen_type", "gen_pmin", "gen_pmax",
-                            "gen_redispatchable", "gen_max_ramp_up",
-                            "gen_max_ramp_down", "gen_min_uptime",
-                            "gen_min_downtime", "gen_cost_per_MW",
-                            "gen_startup_cost", "gen_shutdown_cost",
-                            "gen_renewable"
-                            ]:
-                setattr(self, attr_nm, copy.deepcopy(getattr( type(pp_net), attr_nm)))
-        
-        # handles storages
-        for attr_nm in ["storage_type",
-                        "storage_Emax",
-                        "storage_Emin",
-                        "storage_max_p_prod" ,
-                        "storage_max_p_absorb",
-                        "storage_marginal_cost",
-                        "storage_loss",
-                        "storage_charging_efficiency",
-                        "storage_discharging_efficiency",
-                        ]:
-            setattr(self, attr_nm, copy.deepcopy(getattr( type(pp_net), attr_nm)))
-        
+            
     def _load_grid_pandapower(self, path=None, filename=None):
         if hasattr(type(self), "can_handle_more_than_2_busbar"):
             type(self.init_pp_backend).n_busbar_per_sub = self.n_busbar_per_sub
         self.init_pp_backend.load_grid(path, filename)
-        self._aux_init_pandapower()
-    
-    def _aux_init_pandapower(self):
         self.can_output_theta = True  # i can compute the "theta" and output it to grid2op
 
         self._grid = init(self.init_pp_backend._grid)    
@@ -876,7 +830,7 @@ class LightSimBackend(Backend):
 
         self.topo_vect = np.ones(cls.dim_topo, dtype=dt_int).reshape(-1)
         
-        if cls.shunts_data_available:
+        if type(self).shunts_data_available:
             self.shunt_topo_vect = np.ones(cls.n_shunt, dtype=dt_int)
              # shunts
             self.sh_p = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.NaN).reshape(-1)
@@ -921,7 +875,7 @@ class LightSimBackend(Backend):
         self.__init_topo_vect[:] = self.topo_vect
         self.sh_bus[:] = 1
         
-    def assert_grid_correct_after_powerflow(self) -> None:
+    def assert_grid_correct_after_powerflow(self):
         """
         This method is called by the environment. It ensure that the backend remains consistent even after a powerflow
         has be run with :func:`Backend.runpf` method.
@@ -989,11 +943,11 @@ class LightSimBackend(Backend):
             arr_ = self.shunt_to_subid[is_connected] + self.__nb_bus_before * (arr_[is_connected] - 1)
             self.nb_obj_per_bus[arr_] += 1
 
-    def close(self) -> None:
+    def close(self):
         self.init_pp_backend.close()
         self._grid = None
 
-    def apply_action(self, backendAction: Union["grid2op.Action._backendAction._BackendAction", None]) -> None:
+    def apply_action(self, backendAction):
         """
         Specific implementation of the method to apply an action modifying a powergrid in the pandapower format.
         """
@@ -1075,7 +1029,7 @@ class LightSimBackend(Backend):
             self._shunt_res = self._grid.get_shunts_res_full()
         self._timer_fetch_data_cpp += time.perf_counter() - beg_test
             
-    def runpf(self, is_dc : bool=False) -> Tuple[bool, Union[Exception, None]]:
+    def runpf(self, is_dc=False):
         my_exc_ = None
         res = False
         try:
@@ -1261,7 +1215,7 @@ class LightSimBackend(Backend):
         memo[id(self)] = result
         return result
 
-    def copy(self) -> Self:
+    def copy(self):
         # i can perform a regular copy, everything has been initialized
         mygrid = self._grid
         __me_at_init = self.__me_at_init
@@ -1385,36 +1339,46 @@ class LightSimBackend(Backend):
         self.__me_at_init = __me_at_init
         return res
 
-    def get_line_status(self) -> np.ndarray:
+    def get_line_status(self):
         l_s = self._grid.get_lines_status()
         t_s = self._grid.get_trafo_status()
         return np.concatenate((l_s, t_s)).astype(dt_bool)
 
-    def get_line_flow(self) -> np.ndarray:
+    def get_line_flow(self):
         return self.a_or
-    
-    def get_topo_vect(self) -> np.ndarray:
-        return 1 * self.topo_vect
 
-    def generators_info(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def _grid2op_bus_from_klu_bus(self, klu_bus):
+        res = 0
+        if klu_bus != 0:
+            # object is connected
+            res = 1 if klu_bus < self.__nb_bus_before else 2
+        return res
+
+    def _klu_bus_from_grid2op_bus(self, grid2op_bus, grid2op_bus_init):
+        return grid2op_bus_init[grid2op_bus - 1]
+
+    def get_topo_vect(self):
+        return self.topo_vect
+
+    def generators_info(self):
         return self.cst_1 * self.prod_p, self.cst_1 * self.prod_q, self.cst_1 * self.prod_v
 
-    def loads_info(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def loads_info(self):
         return self.cst_1 * self.load_p, self.cst_1 * self.load_q, self.cst_1 * self.load_v
 
-    def lines_or_info(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def lines_or_info(self):
         return self.cst_1 * self.p_or, self.cst_1 * self.q_or, self.cst_1 * self.v_or, self.cst_1 * self.a_or
 
-    def lines_ex_info(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def lines_ex_info(self):
         return self.cst_1 * self.p_ex, self.cst_1 * self.q_ex, self.cst_1 * self.v_ex, self.cst_1 * self.a_ex
 
-    def storages_info(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def storages_info(self):
         if not self.__has_storage:
             raise RuntimeError("Storage units are not supported with your grid2op version. Please upgrade to "
                                "grid2op >1.5")
         return self.cst_1 * self.storage_p, self.cst_1 * self.storage_q, self.cst_1 * self.storage_v
 
-    def shunt_info(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def shunt_info(self):
         return self.cst_1 * self.sh_p, self.cst_1 * self.sh_q, self.cst_1 * self.sh_v, self.sh_bus
 
     def _compute_shunt_bus_with_compat(self, shunt_bus):
@@ -1448,12 +1412,10 @@ class LightSimBackend(Backend):
         else:
             self._grid.deactivate_trafo(id_ - self.__nb_powerline)
 
-    def get_current_solver_type(self) -> SolverType:
+    def get_current_solver_type(self):
         return self.__current_solver_type
 
-    def reset(self,
-              path : Union[os.PathLike, str],
-              grid_filename : Optional[Union[os.PathLike, str]]=None) -> None:
+    def reset(self, grid_path, grid_filename=None):
         self._fill_nans()
         self._grid = self.__me_at_init.copy()
         self._grid.unset_changes()
@@ -1468,6 +1430,5 @@ class LightSimBackend(Backend):
         self._timer_fetch_data_cpp = 0.
         self._timer_apply_act = 0.
         self._grid.tell_solver_need_reset()
-        self._reset_res_pointers()
         self.sh_bus[:] = 1  # TODO self._compute_shunt_bus_with_compat(self._grid.get_all_shunt_buses())
         self.topo_vect[:] = self.__init_topo_vect  # TODO

LightSim2Grid-0.8.1/lightsim2grid/rewards/__init__.py → LightSim2Grid-0.8.1.dev0/lightsim2grid/securityAnalysis.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2024, RTE (https://www.rte-france.com)
+# Copyright (c) 2023, RTE (https://www.rte-france.com)
 # See AUTHORS.txt
 # This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
 # If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
@@ -6,6 +6,8 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
-__all__ = ["N1ContingencyReward"]
+from lightsim2grid.contingencyAnalysis import ContingencyAnalysisCPP, ContingencyAnalysis
 
-from lightsim2grid.rewards.n1ContingencyReward import N1ContingencyReward
+# Deprecated now, will be removed
+SecurityAnalysisCPP = ContingencyAnalysisCPP
+SecurityAnalysis = ContingencyAnalysis

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/timeSerie.py

@@ -6,23 +6,16 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
-__all__ = ["TimeSeriesCPP", 
+__all__ = ["TimeSerieCPP", "TimeSerie",
            # deprecated
            "Computers"]
 
 import numpy as np
 import warnings
 
+from grid2op.Chronics import Multifolder, GridStateFromFile
 
-try:
-    from grid2op.Chronics import Multifolder, GridStateFromFile
-    from lightsim2grid.lightSimBackend import LightSimBackend
-    __all__.append("TimeSerie")
-    GRID2OP_INSTALLED = True
-except ImportError as exc_:
-    # grid2Op is not installed
-    GRID2OP_INSTALLED = False
-
+from lightsim2grid.lightSimBackend import LightSimBackend
 from lightsim2grid.solver import SolverType
 from lightsim2grid_cpp import TimeSeriesCPP
 
@@ -30,7 +23,7 @@ from lightsim2grid_cpp import TimeSeriesCPP
 Computers = TimeSeriesCPP
 
 
-class ___TimeSerie:
+class TimeSerie:
     """
     This helper class, that only works with grid2op when using a LightSimBackend allows to compute
     the flows (at the origin side of the powerline / transformers). It is roughly equivalent to the
@@ -84,13 +77,6 @@ class ___TimeSerie:
 
     """
     def __init__(self, grid2op_env):
-        if not GRID2OP_INSTALLED:
-            raise RuntimeError("Impossible to use the python wrapper `TimeSerie` "
-                               "when grid2op is not installed. Please fall back to the "
-                               "c++ version (available in python) with:\n"
-                               "\tfrom lightsim2grid.timeSerie import TimeSerieCPP\n"
-                               "and refer to the appropriate documentation.")
-            
         from grid2op.Environment import Environment  # otherwise i got issues...
         if not isinstance(grid2op_env.backend, LightSimBackend):
             raise RuntimeError("This class only works with LightSimBackend")
@@ -277,8 +263,3 @@ class ___TimeSerie:
         self.load_p = 1.0 * data_loader.load_p
         self.load_q = 1.0 * data_loader.load_q
         return self.prod_p, self.load_p, self.load_q
-
-
-if GRID2OP_INSTALLED:
-    TimeSerie = ___TimeSerie
-    

{LightSim2Grid-0.8.1 → LightSim2Grid-0.8.1.dev0}/setup.py

@@ -14,7 +14,7 @@ import warnings
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 
-__version__ = "0.8.1"
+__version__ = "0.8.1.dev0"
 KLU_SOLVER_AVAILABLE = False
 
 # Try to link against SuiteSparse (if available)
@@ -321,8 +321,7 @@ req_pkgs = [
         "pandapower" if sys.version_info < (3, 10) else "pandapower>=2.8",
         "pytest",  # for pandapower see https://github.com/e2nIEE/pandapower/issues/1988
     ]
-if sys.version_info < (3, 11):
-    req_pkgs.append("typing_extensions")
+
 if sys.version_info.major == 3 and sys.version_info.minor <= 7:
     # typing "Literal" not available on python 3.7
     req_pkgs.append("typing_extensions")