Tout a commencé lorsque j'ai reçu la tâche de vérifier plusieurs fichiers XML pour les champs manquants. L'équipe devait s'assurer que tous les champs obligatoires étaient présents dans ces fichiers avant de pouvoir passer aux étapes suivantes. Cela semble assez simple, non ? Enfin, pas tout à fait.

J'ai ouvert le premier fichier XML, parcouru les propriétés, recherché manuellement les champs obligatoires et coché les cases au fur et à mesure. Comme on pouvait s’y attendre, c’est devenu très vite fatiguant. Après seulement quelques minutes dans un seul fichier, mes yeux étaient écarquillés et je n’étais pas vraiment sûr de n’avoir pas manqué quelque chose de crucial. Je veux dire, les XML peuvent être très capricieux, et un seul champ manquant pourrait causer des problèmes majeurs à long terme.

J'avais ce sentiment d'effroi tenace, sachant que j'avais encore un tas de dossiers à parcourir. Et, bien sûr, la précision était essentielle : un champ manquant négligé pouvait entraîner un désastre. Ainsi, après avoir pris quelques respirations profondes et pris un moment pour réfléchir, j'ai décidé qu'il devait y avoir une meilleure façon d'aborder ce problème.

L'Épiphanie : l'automatisation à la rescousse

En tant que programmeur, j'ai eu une idée : pourquoi ne pas écrire un script pour faire ce travail monotone à ma place ? Au lieu de vérifier manuellement chaque champ, je pourrais l'automatiser et garantir l'exactitude tout en préservant ma santé mentale dans le processus. Il était temps d'exploiter la puissance de Python.

Le concept était simple :

• J'avais une liste de champs obligatoires stockés dans un fichier JSON, ce qui rendait le script hautement réutilisable et adaptable. En utilisant cette approche, le script peut facilement traiter d'autres fichiers XML, même ceux ayant des structures différentes. Il vous suffit de mettre à jour le fichier JSON avec les champs requis pour tout nouveau format XML, permettant au script de s'adapter automatiquement aux différents schémas XML sans modification.
• J'avais besoin d'écrire un script Python qui parcourrait chaque fichier XML, vérifierait si l'un des champs obligatoires manquait, puis produirait un résumé.

De cette façon, j'ai pu facilement identifier combien de fois un champ manquait dans chaque fichier, combien de propriétés étaient présentes et obtenir un rapport clair : plus de vérifications manuelles interminables, plus d'erreurs. Voici comment je l’ai abordé.

Écrire le script de l'utilitaire

Tout d'abord, je devais charger la liste des champs obligatoires. Ceux-ci étaient stockés dans un fichier JSON sous la clé requirejs_fields, j'ai donc écrit une fonction pour lire ce fichier :

import os
import json
import xml.etree.ElementTree as ET

def load_required_fields(json_file_path):
    with open(json_file_path, 'r') as file:
        data = json.load(file)
        return data.get("required_fields", [])

Puis est venue la vraie magie. J'ai écrit une fonction pour analyser chaque fichier XML, parcourir ses propriétés et vérifier la présence de chaque champ obligatoire :

def check_missing_fields(file_path, required_fields):
    # Load the XML file
    tree = ET.parse(file_path)
    root = tree.getroot()

    # Initialize variables to store counts and track missing fields
    total_properties = 0
    missing_fields_counts = {field: 0 for field in required_fields}

    # Loop through each property to check for missing fields
    for property in root.findall('.//property'):
        total_properties  = 1
        for field in required_fields:
            # Use the find() method to look for direct children of the property element
            element = property.find(f'./{field}')
            # Check if the field is completely missing (not present)
            if element is None:
                missing_fields_counts[field]  = 1

    # Print the results
    print('-----------------------------------------')
    print(f'File: {os.path.basename(file_path)}')
    print(f'Total number of properties: {total_properties}')
    print('Number of properties missing each field:')
    for field, count in missing_fields_counts.items():
        print(f'  {field}: {count} properties')
    print('-----------------------------------------')

Cette fonction chargeait un fichier XML, comptait le nombre de propriétés et gardait une trace du nombre de propriétés manquantes dans chaque champ obligatoire. La fonction a imprimé un rapport montrant les résultats pour chaque fichier traité.

Enfin, j'ai tout rassemblé dans la fonction main(). Il parcourrait tous les fichiers XML d'un répertoire spécifié et exécuterait la fonction de vérification de champ sur chacun d'eux :

def main():
    # Directory containing XML files
    xml_dir = 'xmls'
    json_file_path = 'required_fields.json'

    # Load required fields from JSON file
    required_fields = load_required_fields(json_file_path)

    # Iterate over each file in the xmls directory
    for file_name in os.listdir(xml_dir):
        if file_name.endswith('.xml'):
            file_path = os.path.join(xml_dir, file_name)
            check_missing_fields(file_path, required_fields)

if __name__ == "__main__":
    main()

Après avoir exécuté le processus, vous recevrez un résumé des résultats similaire à celui-ci :

File: properties.xml
Total number of properties: 4170
Number of properties missing each field:
  Title: 0 properties
  Unit_Number: 0 properties
  Type: 0 properties
  Bedrooms: 0 properties
  Bathrooms: 0 properties
  Project: 0 properties
  Price: 0 properties
  VAT: 0 properties
  Status: 10 properties
  Area: 0 properties
  Location: 100 properties
  Latitude: 30 properties
  Longitude: 0 properties
  Apartment_Floor: 0 properties
  Block: 0 properties
  Phase: 0 properties
  Construction_Stage: 0 properties
  Plot_Size: 0 properties
  Yard: 120 properties
  Description: 0 properties
  gallery: 27 properties

Les résultats : la santé mentale sauvée

Une fois que tout était en place, j'ai exécuté le script sur mon répertoire de fichiers XML. Le résultat était exactement ce dont j'avais besoin : un résumé concis me montrant combien de propriétés manquaient dans chaque fichier, quels champs et le nombre total de propriétés dans chaque XML.

Au lieu de passer des heures à vérifier manuellement chaque fichier, j'ai obtenu ma réponse en quelques secondes. Le script a détecté plusieurs champs manquants que j'aurais peut-être négligés si j'avais continué sur la voie manuelle.

Leçons apprises

1. L'automatisation vous sauve la vie : chaque fois que vous êtes confronté à des tâches répétitives, réfléchissez à la manière dont vous pouvez les automatiser. Non seulement cela vous fera gagner du temps, mais cela réduira également le risque d'erreur humaine.
2. La précision compte : dans des situations comme celles-ci, la précision est primordiale. Un script simple comme celui que j'ai écrit peut garantir que vous ne négligez rien, ce qui est particulièrement important lorsqu'il s'agit de données critiques.
3. Tirez parti de vos compétences en programmation : Parfois, nous sommes obligés de faire les choses manuellement, même lorsque nous avons les compétences nécessaires pour nous faciliter la vie. Prenez un moment pour prendre du recul et demandez-vous : « Existe-t-il un moyen plus efficace de procéder ? »

En fin de compte, ce qui a commencé comme une tâche fastidieuse et sujette aux erreurs s'est transformé en une expérience enrichissante. Désormais, chaque fois que je dois effectuer des tâches qui semblent fastidieuses ou sujettes aux erreurs, je me rappelle la puissance des scripts et de l'automatisation. Je me demande combien d’autres tâches je pourrais rationaliser ensuite…

Vous pouvez rapidement démarrer cette automatisation en clonant le référentiel XML Checker que j'ai créé. Cela vous donnera tout ce dont vous avez besoin, y compris le script et les fichiers d'exemple. À partir de là, vous pourrez exécuter l’automatisation vous-même, la personnaliser pour l’adapter à vos besoins ou étendre encore plus ses fonctionnalités.

Apprécier!