Todo comenzó cuando me dieron la tarea de verificar varios archivos XML en busca de campos faltantes. El equipo necesitaba asegurarse de que todos los campos obligatorios estuvieran presentes en estos archivos antes de poder continuar con los siguientes pasos. Suena bastante simple, ¿verdad? Bueno, no del todo.

Abrí el primer archivo XML, examiné las propiedades, busqué manualmente los campos obligatorios y marqué las casillas a medida que avanzaba. Como era de esperar, se cansó muy rápidamente. Después de solo un par de minutos en un archivo, mis ojos estaban vidriosos y no tenía confianza real en no haberme perdido algo crucial. Quiero decir, los archivos XML pueden ser muy complicados y un solo campo faltante podría causar problemas importantes en el futuro.

Tenía una sensación de pavor persistente, sabiendo que todavía tenía un montón de archivos que revisar. Y, por supuesto, la precisión era fundamental: un campo que se pasara por alto podría significar un desastre. Entonces, después de respirar profundamente unas cuantas veces y pensar un momento, decidí que tenía que haber una mejor manera de abordar esto.

La Epifanía: Automatización al rescate

Siendo programador, tuve una idea: ¿por qué no escribir un script para hacer este trabajo monótono por mí? En lugar de verificar manualmente cada campo, podría automatizarlo y garantizar la precisión mientras mantengo mi cordura en el proceso. Era hora de aprovechar el poder de Python.

El concepto era simple:

• Tenía una lista de campos obligatorios almacenados en un archivo JSON, lo que hizo que el script fuera altamente reutilizable y adaptable. Al utilizar este enfoque, el script puede procesar fácilmente otros archivos XML, incluso aquellos con estructuras diferentes. Simplemente necesita actualizar el archivo JSON con los campos requeridos para cualquier formato XML nuevo, permitiendo que el script se ajuste automáticamente a diferentes esquemas XML sin modificaciones.
• Necesitaba escribir un script de Python que revisara cada archivo XML, verificara si faltaba alguno de los campos obligatorios y luego generara un resumen.

De esta manera, podía identificar fácilmente cuántas veces faltaba un campo en cada archivo, cuántas propiedades estaban presentes y obtener un informe claro: no más comprobaciones manuales interminables, no más errores. Así es como lo abordé.

Escribir el guión de utilidad

Lo primero es lo primero, necesitaba cargar la lista de campos obligatorios. Estos se almacenaron en un archivo JSON bajo la clave campos_requeridos, así que escribí una función para leer este archivo:

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

Entonces vino la verdadera magia. Escribí una función para analizar cada archivo XML, recorrer sus propiedades y verificar la presencia de cada campo obligatorio:

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

Esta función cargó un archivo XML, contó el número de propiedades y realizó un seguimiento de cuántas propiedades faltaban en cada campo obligatorio. La función imprimió un informe que muestra los resultados de cada archivo procesado.

Finalmente, junté todo en la función main(). Iteraría sobre todos los archivos XML en un directorio específico y ejecutaría la función de verificación de campo en cada uno de ellos:

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

Después de ejecutar el proceso, recibirás un resumen de los resultados similar a este:

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

Los resultados: cordura salvada

Una vez que tuve todo en su lugar, ejecuté el script en mi directorio de archivos XML. El resultado fue exactamente lo que necesitaba: un resumen conciso que me mostrara cuántas propiedades en cada archivo faltaban, qué campos y el recuento total de propiedades en cada XML.

En lugar de pasar horas revisando manualmente cada archivo, obtuve mi respuesta en cuestión de segundos. El script detectó varios campos faltantes que podría haber pasado por alto si hubiera seguido la ruta manual.

Lecciones aprendidas

1. La automatización es un salvavidas: Siempre que te enfrentes a tareas repetitivas, piensa en cómo puedes automatizarlas. No sólo le ahorrará tiempo, sino que también reducirá el riesgo de error humano.
2. La precisión importa: En situaciones como estas, la precisión es primordial. Un script simple como el que escribí puede garantizar que no pases por alto nada, lo cual es especialmente importante cuando se trata de datos críticos.
3. Aprovecha tus habilidades de programación: A veces, nos quedamos atrapados en hacer las cosas manualmente, incluso cuando tenemos las habilidades para hacernos la vida más fácil. Tómese un momento para dar un paso atrás y preguntarse: "¿Existe una manera más eficiente de hacer esto?"

Al final, lo que comenzó como una tarea tediosa y propensa a errores se convirtió en una experiencia gratificante. Ahora, cada vez que tengo tareas que me parecen tediosas o propensas a cometer errores, recuerdo el poder de las secuencias de comandos y la automatización. Me pregunto cuántas otras tareas puedo optimizar a continuación…

Puedes comenzar rápidamente con esta automatización clonando el repositorio XML Checker que he creado. Esto le proporcionará todo lo que necesita, incluido el script y los archivos de ejemplo. Desde allí, podrá ejecutar la automatización usted mismo, personalizarla para que se ajuste a sus necesidades o ampliar aún más su funcionalidad.

¡Disfrutar!