Vers des fichiers de configuration Python sans effort version 1

Introduction

Comme indiqué dans l'article précédent, la version simpliste regorge de problèmes, notamment d'évolutivité, de maintenabilité et d'extensibilité.

Une extension simple de la version Ø consiste à essayer de masquer les détails de configuration Python derrière une classe de propriété. Il s'agit d'implémenter une pseudo-classe de données qui expose un ensemble de propriétés qui permettent à un développeur d'effectuer simplement des appels de propriété set et get pour récupérer et conserver les valeurs de propriété.

Du point de vue des responsables, cette implémentation devrait prendre en charge les fonctionnalités suivantes.

1. Autoriser la création automatique de sections de configuration si elles sont manquantes
2. Autoriser la création automatique de valeurs de propriété si elles sont manquantes
3. Les propriétés doivent être implémentées à la fois en lecture et en écriture.
4. Afin d'éviter les coûts de démarrage pour ce qui précède lorsqu'une application instancie cette classe tout au long de l'application, cette classe doit être un Singleton.

Représentation de classe

Le diagramme de classe UML suivant décrit une classe qui répondrait aux exigences de l'introduction. La classe ConfiguratonProperties répond aux exigences 1 et 2 avec les méthodes protégées .createMissingSections et .createMissingKeys

Créer des implémentations

Créer des sections manquantes

Le code suivant montre l'implémentation. Notez que des sections supplémentaires nécessitent des mises à jour du code de cette méthode

SECTION_GENERAL:  str = 'General'
SECTION_DATABASE: str = 'Database'

def _createMissingSections(self):
    """
    Create missing sections.  Add additional calls for
    each defined section
    """
    self._createMissingSection(SECTION_GENERAL)
    self._createMissingSection(SECTION_DATABASE)

Le code de section manquant est le suivant.

def _createMissingSection(self, sectionName: str):
    """
    Only gets created if it is missing
    Args:
        sectionName: The potential section to create
    """
    hasSection: bool = self._configParser.has_section(sectionName)
    self.logger.info(f'hasSection: {hasSection} - {sectionName}')
    if hasSection is False:
        self._configParser.add_section(sectionName)

Créer des clés manquantes

Le code suivant montre l'implémentation. Notez encore une fois que si nous ajoutons une section supplémentaire, le développeur doit ajouter une boucle supplémentaire pour la nouvelle section.

GENERAL_PREFERENCES: Dict[str, str] = {
    'debug':    'False',
    'logLevel': 'Info'
}

DATABASE_PREFERENCES: Dict[str, str] = {
    'dbName': 'example_db',
    'dbHost': 'localhost',
    'dbPort': '5432'
}

def _createMissingKeys(self):
    """
    Create missing keys and their values.  Add additional calls for
    each defined section.
    """
    for keyName, keyValue in GENERAL_PREFERENCES.items():
        self._createMissingKey(sectionName=SECTION_GENERAL, keyName=keyName, defaultValue=keyValue)
    for keyName, keyValue in DATABASE_PREFERENCES.items():
        self._createMissingKey(sectionName=SECTION_DATABASE, keyName=keyName, defaultValue=keyValue)

Le code clé manquant est le suivant. Notez que toutes les clés manquantes sont immédiatement conservées.

def _createMissingKey(self, sectionName: str, keyName: str, defaultValue: str):
    """
    Only gets created if it is missing.  The configuration file is updated
    immediately for each missing key and its value

    Args:
        sectionName:   The section name where the key resides
        keyName:       The key name
        defaultValue:  Itsß value
    """
    if self._configParser.has_option(sectionName, keyName) is False:
        self._configParser.set(sectionName, keyName, defaultValue)
        self._saveConfiguration()

Propriétés de classe

Des exemples d'implémentations pour l'exigence 3 suivent.

Propriétés de chaîne

Notez que la définition d'une propriété écriture directe dans le fichier de configuration en définissant la propriété et en la rendant immédiatement persistante. Les propriétés de lecture sont effectivement lues en raison de la façon dont nous écrivons immédiatement les propriétés définies.

@property
def dbName(self) -> str:
    return self._configParser.get(SECTION_DATABASE, 'dbName')

@dbName.setter
def dbName(self, newValue: str):
    self._configParser.set(SECTION_DATABASE, 'dbName', newValue)
    self._saveConfiguration()

Propriétés entières

Les propriétés entières utilisent la méthode .getint pour récupérer la valeur. Lors de la définition de la propriété, le développeur doit la convertir manuellement en chaîne.

@property
def dbPort(self) -> int:
    return self._configParser.getint(SECTION_DATABASE, 'dbPort')

@dbPort.setter
def dbPort(self, newValue: int):
    self._configParser.set(SECTION_DATABASE, 'dbPort', str(newValue))
    self._saveConfiguration()

Propriétés booléennes

Les propriétés booléennes utilisent la méthode .getboolean pour récupérer leur valeur. Lors de la définition de la propriété, le développeur doit la convertir manuellement en chaîne.

SECTION_GENERAL:  str = 'General'
SECTION_DATABASE: str = 'Database'

def _createMissingSections(self):
    """
    Create missing sections.  Add additional calls for
    each defined section
    """
    self._createMissingSection(SECTION_GENERAL)
    self._createMissingSection(SECTION_DATABASE)

Propriétés d'énumération

Je ne couvrirai pas les propriétés d’énumération dans cet article. Il existe deux manières de les conserver, par leur nom ou par leur valeur. Chaque mécanisme nécessite une manière légèrement différente de désérialiser les valeurs en un type d'énumération.

Accès et modification des propriétés

L'extrait de code suivant montre comment accéder aux propriétés et les modifier.

def _createMissingSection(self, sectionName: str):
    """
    Only gets created if it is missing
    Args:
        sectionName: The potential section to create
    """
    hasSection: bool = self._configParser.has_section(sectionName)
    self.logger.info(f'hasSection: {hasSection} - {sectionName}')
    if hasSection is False:
        self._configParser.add_section(sectionName)

L'extrait ci-dessus produit le résultat suivant

GENERAL_PREFERENCES: Dict[str, str] = {
    'debug':    'False',
    'logLevel': 'Info'
}

DATABASE_PREFERENCES: Dict[str, str] = {
    'dbName': 'example_db',
    'dbHost': 'localhost',
    'dbPort': '5432'
}

def _createMissingKeys(self):
    """
    Create missing keys and their values.  Add additional calls for
    each defined section.
    """
    for keyName, keyValue in GENERAL_PREFERENCES.items():
        self._createMissingKey(sectionName=SECTION_GENERAL, keyName=keyName, defaultValue=keyValue)
    for keyName, keyValue in DATABASE_PREFERENCES.items():
        self._createMissingKey(sectionName=SECTION_DATABASE, keyName=keyName, defaultValue=keyValue)

Conclusion

Le code source de cet article est ici. La classe de support SingletonV3 est ici

Le résultat de la mise en œuvre m'a d'abord laissé satisfait en tant que consommateur du code. J'ai pu obtenir et définir des propriétés typées. Cependant, en tant que responsable du code, je devais mettre à jour manuellement les structures de données du code et les boucles de code chaque fois que j'ajoutais de nouvelles sections et de nouvelles propriétés. De plus, tout ce que j'en ai vraiment retiré, c'est un mécanisme/modèle à utiliser chaque fois que j'ai besoin de nouvelles propriétés de configuration dans différentes applications.

Avantages

• Accès facile et sécurisé aux propriétés de l'application
• L'invocation du singleton dans différentes parties de mon application a fourni un accès cohérent et fiable aux propriétés, quelle que soit la partie de l'application qui modifiait les valeurs

Inconvénients

• Les mises à jour pour ajouter de nouvelles propriétés étaient fastidieuses
• Beaucoup de code de plaque passe-partout
• Aucune réutilisation dans diverses applications. En gros, je viens d'avoir un modèle

Voir mon prochain article qui documente une implémentation alternative pour remédier aux inconvénients que j'ai répertoriés, tout en conservant les avantages.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!