Utiliser Python pour analyser les fichiers de configuration

  • FrançaisFrançais



  • Parfois, un programme a besoin de suffisamment de paramètres pour que les mettre tous en tant qu’arguments de ligne de commande ou variables d’environnement n’est ni agréable ni faisable. Dans ces cas, vous voudrez utiliser un fichier de configuration.

    Il existe plusieurs formats courants pour les fichiers de configuration. Parmi eux se trouvent les vénérables (bien que parfois sous-définis) INI format, le populaire mais parfois difficile à écrire à la main JSON format, le vaste mais parfois surprenant dans les détails YAML format, et le plus récent ajout, TOML, dont beaucoup de gens n’ont pas encore entendu parler.

    Votre première tâche consiste à choisir un format, puis à documenter ce choix. Avec cette partie facile à l’écart, il est temps d’analyser la configuration.

    C’est parfois une bonne idée d’avoir une classe qui correspond aux données “abstraites” dans la configuration. Parce que ce code ne fera rien avec la configuration, c’est le moyen le plus simple d’afficher la logique d’analyse.

    Imaginez la configuration d’un processeur de fichiers : il comprend un répertoire d’entrée, un répertoire de sortie et les fichiers à récupérer.

    La définition abstraite de la classe de configuration pourrait ressembler à ceci :

    from __future__ import annotations
    import attr

    @attr.frozen
    class Configuration:
        @attr.frozen
        class Files:
            input_dir: str
            output_dir: str
        files: Files
        @attr.frozen
        class Parameters:
            patterns: List[str]
        parameters: Parameters

    Pour simplifier le code spécifique au format, vous allez également écrire une fonction pour analyser cette classe à partir des dictionnaires. Notez que cela suppose que la configuration utilisera des tirets et non des traits de soulignement. Ce genre de divergence n’est pas rare.

    def configuration_from_dict(details):
        files = Configuration.Files(
            input_dir=details["files"]["input-dir"],
            output_dir=details["files"]["output-dir"],
        )
        parameters = Configuration.Paraneters(
            patterns=details["parameters"]["patterns"]
        )
        return Configuration(
            files=files,
            parameters=parameters,
        )

    JSON

    JSON (JavaScript Object Notation) est un format de type JavaScript.

    Voici un exemple de configuration au format JSON :

    json_config = """
    {
        "
    files": {
            "
    input-dir": "inputs",
            "
    output-dir": "outputs"
        },
        "
    parameters": {
            "
    patterns": [
                "
    *.txt",
                "
    *.md"
            ]
        }
    }
    "
    ""

    La logique d’analyse analyse le JSON dans les structures de données intégrées de Python (dictionnaires, listes, chaînes) à l’aide du json module, puis crée la classe à partir du dictionnaire :

    import json
    def configuration_from_json(data):
        parsed = json.loads(data)
        return configuration_from_dict(parsed)

    INI

    Le format INI, à l’origine populaire sur Windows, est devenu une norme de configuration de facto.

    Voici la même configuration qu’un INI :

    ini_config="""
    [files]
    input-dir = inputs
    output-dir = outputs[parameters]
    patterns = ['*.txt', '*.md']
    "

    ""

    Python peut l’analyser à l’aide de la fonction intégrée configparser module. L’analyseur se comporte comme un dict-like object, donc il peut être passé directement à configuration_from_dict:

    import configparser

    def configuration_from_ini(data):
        parser = configparser.ConfigParser()
        parser.read_string(data)
        return configuration_from_dict(parser)

    YAML

    YAML (Yet Another Markup Language) est une extension de JSON conçue pour être plus facile à écrire à la main. Il y parvient, en partie, en ayant une longue spécification.

    Voici la même configuration en YAML :

    yaml_config = """
    files:
      input-dir: inputs
      output-dir: outputs
    parameters:
      patterns:
      - '*.txt'
      - '*.md'
    "
    ""

    Pour que Python puisse analyser cela, vous devrez installer un module tiers. Le plus populaire est PyYAML (pip install pyyaml). L’analyseur YAML renvoie également des types de données Python intégrés qui peuvent être transmis à configuration_from_dict. Cependant, l’analyseur YAML attend un flux, vous devez donc convertir la chaîne en flux.

    import io
    import yaml
    def configuration_from_yaml(data):
        fp = io.StringIO(data)
        parsed = yaml.safe_load(fp)
        return configuration_from_dict(parsed)

    TOML

    TOML (Tom’s Own Markup Language) est conçu pour être une alternative légère à YAML. La spécification est plus courte et elle est déjà populaire à certains endroits (par exemple, le gestionnaire de packages de Rust, Cargo, l’utilise pour la configuration des packages).

    Voici la même configuration qu’un TOML :

    toml_config = """
    [files]
    input-dir = "inputs"
    output-dir = "outputs"[parameters]
    patterns = [ "*.txt", "*.md",]
    """

    Pour analyser TOML, vous devez installer un package tiers. Le plus populaire s’appelle, simplement, toml. Comme YAML et JSON, il renvoie des types de données Python de base.

    import toml
    def configuration_from_toml(data):
        parsed = toml.loads(data)
        return configuration_from_dict(parsed)

    Résumé

    Le choix d’un format de configuration est un compromis subtil. Cependant, une fois que vous avez pris la décision, Python peut analyser la plupart des formats populaires en utilisant une poignée de lignes de code.

    Source

    N'oubliez pas de voter pour cet article !
    1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
    Loading...

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.