Load environment with custom config.py file not in root directory

[kostialjn]

Is your feature request related to a problem? Please describe.

I would like to be able to point to a custom config.py file at grid2op.make
For the same grid I have several config.py files and I would like to be able to switch config without having to duplicate my environment folder

Describe the solution you'd like

Ex. This is how i would like it to be done:

import grid2op
env_name = "environment/folder/"
env_conf_1 = grid2op.make(env_name, _config_path="environment/folder/configs/config_1.py")
env_conf_2 = grid2op.make(env_name, _config_path="environment/folder/configs/config_2.py")

Describe alternatives you've considered

Other alternatives :

• Duplicate entire environment folder
• Import config files using importlib and load env using grid2op.make(env_name, **config_data)

Both those alternatives seem suboptimal

[BDonnot]

Hello,

Today it seems to be relatively hard to do. Indeed, in multiple places in grid2op there are calls like "from config import XXX" which would make such a feature rather hard to do.

The "config.py" file was initially present to offer a some kind of default customization for the environment. What I mean by that is:

• grid2op has some default behaviour, shared for all environment
• config.py offers some basic default configuration, different from the config for each environment
• a call to grid2op.make(...) can (at least in theory, if that is not the case then we can work on it for sure) override any "default" configuration.

First "solution"

So I am not entirely sure 2 configurations are needed. If you want 2 confs you can store them (as yaml, json or serialization mechanism you want) and do something like this (example with json):

import json
import grid2op
with open("environment/folder/configs/config_1.json", "r", encoding="utf-8") as f:
    conf1 = json.load(f)

with open("environment/folder/configs/config_2.json", "r", encoding="utf-8") as f:
    conf2 = json.load(f)

env_conf1 = grid2op.make(env_name, **conf1)
env_conf2 = grid2op.make(env_name, **conf2)

Second "solution"

Or you can also do an "env with config" function that will "bind" the two above call if that is more convenient for you, for example:

import grid2op
import json
env_name = "environment/folder/"

def make_with_config(env_name, config_name):
    with open(os.path.join(env_name, config_name), "r", encoding="utf-8") as f:
        conf = json.load(f)
    return grid2op.make(env_name, **conf)

What could also be added in grid2op is this feature in env.make with either:

• the creation of a special kwargs "_config_path" that would affect dynamically the "kwargs" provided in the call to "env.make" (more work to do, but probably closer to what you had in mind in PR feat: Make env using custom config file path in kwargs #739 ). Basically, you add to the "kwargs" of env.make (and make_from_path and multimix.make etc.) every entries present in the config.json (or config.yaml or other) in the appropriate kwargs at the top of these functions
• the creation of a new function that could be imported from grid2op, called for example grid2op.make_with_config that would be inspired from the above function.

NB: I rely on more standard serialization here (json or yaml) but as long as your "config" file can be easily mapped to a python dict, it can be whatever, including a python script. So for example, you could achieve what you want with a script called "config_1.py" (which would be another one that config.py (can be empty if you don't want anything from it)) and export a python dict. So you would from config_1 import config and then grid2op.make(env_name, **config) I find it less elegant and more error prone however (and would prefer json or yaml)

Third "solution"

You can have the following layout:

environment/folder/grid.xiidm
environment/folder/config1/config.py
environment/folder/config2/config.py

And change the grid location, the time series location etc. when calling grid2op.make("environment/folder/config1", grid_path="environment/folder/", ...) to get "env_conf1" and likewise to get env_conf2

You can have some hints of the kwargs you need to pass looking at https://grid2op.readthedocs.io/en/latest/makeenv.html#customize-your-environment

Fourth solution

Create a dedicated environment wrapper, like in https://grid2op.readthedocs.io/en/latest/user/environment.html#grid2op.Environment.MaskedEnvironment or https://grid2op.readthedocs.io/en/latest/user/environment.html#grid2op.Environment.TimedOutEnvironment (a few real line of python each) to have the behaviour that you want.

Depending on the kwargs you want to set, this last solution might be really hard to implement (especially if you change the backend, the time series or anything "core" to grid2op).

This is why I put it last, because it's probably the less convenient.

[kostialjn]

Hello !

Just to clarify, I thought of a solution with config.py Python file because YAML or JSON configs force us to create a deserialization function which can be quite difficult, as kwargs of the grid2op.make function expects Python objects that can be grid2op classes

[BDonnot]

Hello,

You can deserialize pretty quickly json with your isecase I think.

For example

dict_ = json_loaded

if dict_["backend"] == "lightsim2grid":
   from lightsim2grid import LightsimBackend
   backend = LightsimBackend(**dict_["backend_kwargs"]
elif dict["backend"] == "pypowsybl":
    from pypowsybl2grid import PypowsyblBackend
    backend = ...
else:
   raise RuntimeError(...)

Del dict_["backend"]
Del dict_["backend_kwargs"]

# and proceed with one of the example above

You can even have a function to convert json to useful grid2op objects (basically wrapping this code, and probably other) somewhere, for example in "powergrid dataset" where this would be ideal.

Having everything in grid2op would be harder to do because we would need to think of all possible usecase but definitely agree this would be a nice addition to grid2op.