Alles begann damit, dass ich die Aufgabe erhielt, mehrere XML-Dateien auf fehlende Felder zu überprüfen. Das Team musste sicherstellen, dass alle Pflichtfelder in diesen Dateien vorhanden waren, bevor wir mit unseren nächsten Schritten fortfahren konnten. Klingt einfach genug, oder? Na ja, nicht ganz.

Ich habe die erste XML-Datei geöffnet, die Eigenschaften durchsucht, manuell nach den erforderlichen Feldern gesucht und dabei die Kästchen angekreuzt. Wie zu erwarten war, wurde es sehr schnell anstrengend. Schon nach ein paar Minuten in einer Datei wurden meine Augen glasig und ich hatte kein wirkliches Vertrauen, dass ich nichts Entscheidendes verpasst hatte. Ich meine, XMLs können so knifflig sein und ein einzelnes fehlendes Feld könnte später große Probleme verursachen.

Ich hatte dieses nagende Gefühl der Angst, weil ich wusste, dass ich noch eine Menge Akten durchgehen musste. Und natürlich war die Genauigkeit von entscheidender Bedeutung – ein übersehenes fehlendes Feld könnte eine Katastrophe bedeuten. Nachdem ich ein paar Mal tief durchgeatmet und einen Moment nachgedacht hatte, kam ich zu dem Schluss, dass es einen besseren Weg geben musste, das Problem anzugehen.

Die Offenbarung: Automatisierung zur Rettung

Als Programmierer hatte ich eine Idee: Warum nicht ein Skript schreiben, um diese eintönige Arbeit für mich zu erledigen? Anstatt jedes einzelne Feld manuell zu überprüfen, könnte ich es automatisieren und Genauigkeit garantieren und dabei gleichzeitig meinen Verstand retten. Es war an der Zeit, die Leistungsfähigkeit von Python zu nutzen.

Das Konzept war einfach:

• Ich hatte eine Liste der erforderlichen Felder in einer JSON-Datei gespeichert, wodurch das Skript in hohem Maße wiederverwendbar und anpassungsfähig war. Durch diesen Ansatz kann das Skript problemlos andere XML-Dateien verarbeiten, auch solche mit unterschiedlichen Strukturen. Sie müssen lediglich die JSON-Datei mit den erforderlichen Feldern für jedes neue XML-Format aktualisieren, damit sich das Skript ohne Änderungen automatisch an verschiedene XML-Schemas anpassen kann.
• Ich musste ein Python-Skript schreiben, das jede XML-Datei durchging, überprüfte, ob eines der erforderlichen Felder fehlte, und dann eine Zusammenfassung ausgab.

Auf diese Weise konnte ich leicht erkennen, wie oft ein Feld in jeder Datei fehlte, wie viele Eigenschaften vorhanden waren, und einen klaren Bericht erhalten – keine endlosen manuellen Überprüfungen mehr, keine Fehler mehr. So bin ich vorgegangen.

Schreiben des Utility-Skripts

Das Wichtigste zuerst: Ich musste die Liste der erforderlichen Felder laden. Diese wurden in einer JSON-Datei unter dem Schlüssel „required_fields“ gespeichert, daher habe ich eine Funktion geschrieben, um diese Datei zu lesen:

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", [])

Dann kam die wahre Magie. Ich habe eine Funktion geschrieben, um jede XML-Datei zu analysieren, ihre Eigenschaften zu durchlaufen und zu prüfen, ob jedes erforderliche Feld vorhanden ist:

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('-----------------------------------------')

Diese Funktion hat eine XML-Datei geladen, die Anzahl der Eigenschaften gezählt und verfolgt, wie viele Eigenschaften in jedem erforderlichen Feld fehlten. Die Funktion hat einen Bericht mit den Ergebnissen für jede verarbeitete Datei ausgedruckt.

Abschließend habe ich alles in der Funktion main() zusammengefügt. Es würde alle XML-Dateien in einem angegebenen Verzeichnis durchlaufen und die Feldprüfungsfunktion für jede von ihnen ausführen:

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()

Nachdem Sie den Vorgang ausgeführt haben, erhalten Sie eine Zusammenfassung der Ergebnisse ähnlich dieser:

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

Das Ergebnis: Die geistige Gesundheit ist gerettet

Sobald ich alles eingerichtet hatte, führte ich das Skript in meinem Verzeichnis mit XML-Dateien aus. Die Ausgabe war genau das, was ich brauchte: eine prägnante Zusammenfassung, die mir zeigt, wie viele Eigenschaften in jeder Datei welche Felder fehlten und wie viele Eigenschaften in jedem XML insgesamt vorhanden waren.

Anstatt Stunden damit zu verbringen, jede Datei manuell zu überprüfen, erhielt ich meine Antwort innerhalb von Sekunden. Das Skript hat mehrere fehlende Felder entdeckt, die ich möglicherweise übersehen hätte, wenn ich den manuellen Weg weitergegangen wäre.

Gelernte Lektionen

1. Automatisierung ist ein Lebensretter: Wenn Sie mit wiederkehrenden Aufgaben konfrontiert werden, denken Sie darüber nach, wie Sie diese automatisieren können. Dadurch sparen Sie nicht nur Zeit, sondern verringern auch das Risiko menschlicher Fehler.
2. Genauigkeit zählt: In Situationen wie diesen ist Genauigkeit von größter Bedeutung. Ein einfaches Skript wie das, das ich geschrieben habe, kann sicherstellen, dass Sie nichts übersehen, was besonders wichtig ist, wenn Sie mit kritischen Daten arbeiten.
3. Nutzen Sie Ihre Programmierkenntnisse: Manchmal sind wir damit beschäftigt, Dinge manuell zu erledigen, selbst wenn wir über die Fähigkeiten verfügen, die unser Leben einfacher machen. Nehmen Sie sich einen Moment Zeit, einen Schritt zurückzutreten und sich zu fragen: „Gibt es einen effizienteren Weg, dies zu tun?“

Was als mühsame und fehleranfällige Aufgabe begann, wurde am Ende zu einer lohnenden Erfahrung. Wenn ich jetzt Aufgaben bekomme, die mir mühsam oder fehleranfällig vorkommen, erinnere ich mich an die Leistungsfähigkeit von Skripten und Automatisierung. Ich frage mich, wie viele andere Aufgaben ich als nächstes rationalisieren kann …

Sie können schnell mit dieser Automatisierung beginnen, indem Sie das von mir erstellte XML Checker-Repository klonen. Dadurch erhalten Sie alles, was Sie benötigen, einschließlich des Skripts und der Beispieldateien. Von dort aus können Sie die Automatisierung selbst ausführen, sie an Ihre Bedürfnisse anpassen oder ihre Funktionalität noch weiter erweitern.

Genießen!