Condition sur les imports / python

Oui c'est ça.

params.py

def load_params(i):
    if i == 0:
        return {
           "key" : "xxx",
           "output_dir" : "output",
           # ...
        }
    elif i == 1:
        return {
           "key" : "yyy",
           "output_dir" : "output2",
           # ...
        }
    #...
    else:
        raise RuntimeError(f"load_params: Invalid i parameter: {i}")

main.py

import sys
from optparse import OptionParser
    
def main():
    parser = OptionParser()
    parser.add_option(
        "-i", "--config-index",
        metavar = "INT",
        type    = "int",
        dest    = "config_index",
        help    = "Index of the configuration. 0 = ... ; 1 = ...",
        default = 0
    )
    (options, args) = parser.parse_args()
    print(f"options.config_index = {options.config_index}")
    params = load_params(options.config_index)
    print(params)
    # ...
    return 0
        
if __name__ == "__main__":
    sys.exit(main())

Exécution

(mando@silk) (~) $ python3 toto.py -i 1
options.config_index = 1
{'key': 'yyy', 'output_dir': 'output2'}

(mando@silk) (~) $ python3 toto.py --config-index 1
options.config_index = 1
{'key': 'yyy', 'output_dir': 'output2'}

(mando@silk) (~) $ python3 toto.py -i 0
options.config_index = 0
{'key': 'xxx', 'output_dir': 'output'}

(mando@silk) (~) $ python3 toto.py
options.config_index = 0
{'key': 'xxx', 'output_dir': 'output'}

Ici j'ai pris un entier mais tu peux imaginer travailler avec une chaîne, un booléan, bref ce qui est adapté à tes besoins (voir un tutoriel sur optparse). Ton programme peut bien évidemment avoir plusieurs options. On pourrait d'ailleur imaginer que tu aies un paramètre en ligne de commande pour chacun de tes paramètres (url de l'api, output_dir, etc...) + un paramètre qui les initialise toute en chargeant un fichier de configuration (ini ou json). On évite toutefois de mettre les clés en paramètres car sinon elles apparaissent en clair dans la table des processus.

Bonne chance

Ok, merci beaucoup.

J'ai donc adapté le script gen.py (ou main.py), pour récupérer les différents paramètres et les mettre dans des variables globales, comme ceci :

url = ""
key = ""
output_dir = ""

# [...]

def main():

   # [...]

    global url
    url = params["url"]
    global key
    key = params["key"]
    global output_dir
    output_dir = params["output_dir"]

    return 0

# We launch the search for parameters
main()


# [...]

J'ai juste une petite question, la ligne

if __name__ == '__main__': 
      sys.exit(main())

signifie que la fonction main est exécuté seulement si le script exécuté en ligne de commande, et non importé c'est cela ?

• Concernant ton script, je te déconseille l'utilisation de variables globales. C'est généralement une mauvaise habitude car ça nuit à la lisibilité (on ne voit pas l'ensemble des paramètres d'une fonction) et ça peut avoir des effets de bords gênant (programmation parallèle). Mieux vaut les passer explicitement en paramètres.
• Concernant les deux lignes en fin de fichier, oui cela sert quand on exécute le script python en ligne de commande.
• Est-ce que ton problème est résolu ou as-tu d'autres questions ?

Ces autres fonctions devraient simplement recevoir url, key etc en paramètre. Ça alourdit un peu la signature et l'appel des fonctions en questions, mais au moins on sait de quoi elles dépendent. Donc admettons que les fonctions en questions soient f(x, y) et g(x, y), que f a besoin de api et url, et que g à besoin de url et key, alors elles elles deviennent f(x, y, api, url) et g(x, y, url, key)

Ensuite, si ça a un sens de rassembler f, g, api, url et key, tu peux imaginer définir un objet qui aura api, url et key en attribut puis f et g en méthodes. En tant que méthodes, f et g auront accès à self.api, self.url, self.key.

class Gateway:
    def __init__(self, url, api, key):
        self.url = url
        self.api = api
        self.key = key
    def f(self, x, y):
        print(x, y, self.url, self.api)
    def f(self, x, y):
        print(x, y, self.api, self.key)

gateway = Gateway("url", "api", "key")
gateway.f(1, 2)
gateway.g(3, 4)

Ainsi la signature de f et g est plus légère.