Obtenez des options en Python à partir des fichiers JSON et des arguments de ligne de commande

Il s'agit de la version Python d'un autre article, «Obtenir des options dans Ruby à partir des fichiers JSON et des arguments de ligne de commande» (https://qiita.com/aikige/items/014139c0b1ae70139477). Puisque l'utilisation de Python a augmenté récemment, je partagerai le résultat de l'examen de la façon d'écrire la même chose avec Python.

Concept de base

1. Rassemblez les options dans un seul objet. Exemple: options de classe
2. Lisez les options du fichier JSON lors de la création de l'objet. Exemple: opt = Options ('some.json') lit les options d'un fichier JSON.
3. Utilisez l'attribut de l'objet pour accéder aux options. Exemple: vous pouvez y accéder comme opt.option_1.
4. Capturez les arguments de ligne de commande à l'aide de Argparse.
5. L'objet facultatif a une méthode pour récupérer la valeur du résultat généré par Arguparse. Exemple: importez avec quelque chose comme opt.import_opt (options).

Exemple d'implémentation

https://gist.github.com/aikige/470f4ef93753638cc3a18d62e195eb19

#!/usr/bin/env python

import json
import os

class Options:
    OPTS = { 'option_1': 'bool', 'option_2': 'str' }

    def __init__(self, filename='config.json'):
        if (os.path.exists(filename)):
            with open(filename) as f:
                self.import_dict(json.load(f))

    def import_attr(self, key, value):
        if (value is None):
            return
        if (isinstance(value, eval(self.OPTS[key]))):
            setattr(self, key, value)
        else:
            raise ValueError("invalid type")

    def import_dict(self, d):
        for key in self.OPTS.keys():
            if (key in d.keys()):
                self.import_attr(key, d[key])

    def import_opt(self, args):
        for key in self.OPTS.keys():
            if (hasattr(args, key)):
                self.import_attr(key, getattr(args, key))

if __name__ == '__main__':
    import argparse

    opt = Options()
    print(vars(opt))

    parser = argparse.ArgumentParser()
    parser.add_argument('-1', '--option_1', action='store_true', default=None)
    parser.add_argument('-2', '--option_2', type=str)
    args = parser.parse_args()
    print(vars(args))
    opt.import_opt(args)
    print(vars(opt))

Principales différences par rapport à la version Ruby

1. Contrairement à Ruby, Python a un type bool, donc la détermination de type peut être incorporée relativement facilement ( import_attr).
2. Dans le cas de Python, Arrgparse est utilisé pour l'analyse des options, de sorte que les méthodes d'analyse JSON et d'analyse des arguments ne sont pas unifiées. , Légèrement redondant.
3. Dans le cas de Python, il semble un peu difficile de rendre l'attribut en lecture seule, donc je l'ai omis.