Prueba expresiones regulares de IA con casos pequeños en Python

Un asistente de IA puede crear una expresión regular que acepte tu ejemplo y aun así admita identificadores incorrectos. Antes de usarla para limpiar una hoja de cálculo o validar una importación, pruébala con un pequeño conjunto de cadenas cuyas respuestas ya conozcas.

Este tutorial crea una prueba de aceptación local con la biblioteca estándar de Python. No necesitas cuenta de un modelo, instalar paquetes ni usar datos reales de clientes. Los patrones siguientes son ejemplos escritos a mano de errores plausibles, no resultados medidos de un producto de IA.

1. Escribe la regla antes de pedir ayuda a la IA

Supongamos que un identificador interno debe contener exactamente dos letras ASCII mayúsculas, un guion y cuatro dígitos ASCII. Se permiten ceros iniciales; no se permiten minúsculas, espacios, caracteres adicionales ni un salto de línea final. Es un formato inventado, no un estándar para correos electrónicos o nombres internacionales.

Pide al asistente un patrón para re de Python, especifica esas reglas y solicita ejemplos aceptados y rechazados. No uses únicamente los ejemplos del asistente: escribe primero tus propios casos y reserva algunos adicionales para revisarlos después.

Valida la cadena completa. fullmatch() solo tiene éxito si coincide toda la cadena; search() puede encontrar un fragmento aparentemente válido dentro de una entrada inválida. Referencia de expresiones regulares de Python.

2. Crea un conjunto de pruebas pequeño y legible

Guarda lo siguiente como regex_check.py en un directorio de trabajo vacío. Contiene dos identificadores válidos y ocho entradas inválidas que cubren límites de longitud, mayúsculas y minúsculas, prefijos no deseados, espacios en blanco y dígitos Unicode.

import re
import sys

CASES = [
    ("AB-0000", True),
    ("ZX-9876", True),
    ("AB-123", False),
    ("AB-12345", False),
    ("ab-1234", False),
    ("XXAB-1234", False),
    ("AB-1234\n", False),
    ("AB-\u0661\u0662\u0663\u0664", False),
    ("", False),
    ("AB-12 4", False),
]
PATTERNS = {
    "candidate": r"[A-Z]{2}-\d{4}",
    "fixed": r"[A-Z]{2}-[0-9]{4}",
    "reject_all": r"(?!)",
    "accept_all": r"[\s\S]*",
}


def main(name):
    pattern = re.compile(PATTERNS[name])
    failures = 0
    for text, expected in CASES:
        actual = pattern.fullmatch(text) is not None
        if actual != expected:
            failures += 1
            print(f"FAIL {ascii(text)}: expected={expected}, actual={actual}")
    print(f"{name}: {len(CASES) - failures}/{len(CASES)} passed")
    return int(failures > 0)


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1]))

El patrón candidate parece razonable, pero los patrones de cadenas de Python interpretan \d como dígitos decimales Unicode, no solo del 0 al 9. Los dígitos arábigo-índicos de un caso revelan esa discrepancia. El patrón fixed expresa el requisito ASCII mediante [0-9]. Documentación de Python sobre clases de dígitos.

Observa que no hemos cambiado las respuestas esperadas para que pase el patrón corregido. La especificación, no la sugerencia generada, determina qué es correcto.

3. Ejecuta el candidato y los controles negativos

Ejecuta cada comando por separado desde el directorio que contiene el archivo:

python3 regex_check.py candidate
python3 regex_check.py fixed
python3 regex_check.py reject_all
python3 regex_check.py accept_all

Los resultados comprobados localmente con Python 3.11.4 son:

Las ejecuciones fallidas también muestran cada entrada discrepante con sus valores booleanos esperado y real. Los cuatro comandos dejan stderr vacío. El código de salida 1 es intencionado en los tres patrones fallidos; permite que una automatización detenga una importación.

Los controles comprueban el comprobador: un validador que rechaza cualquier entrada debe fallar los casos positivos, y uno que acepta cualquier entrada debe fallar los negativos. Es el mismo principio de las pruebas de SQL escrito por IA con resultados conocidos.

Exige que pasen todos los casos, no solo un porcentaje alto. Aquí, un patrón que siempre rechaza obtiene un 80 % aunque resulte inútil.

4. Resuelve los problemas sin debilitar la regla

• Pasa un sufijo o prefijo inválido: revisa tanto el código que llama al patrón como el propio patrón. Conserva fullmatch() en lugar de cambiar a una coincidencia parcial.
• Se aceptan espacios en blanco inesperados: comprueba si un paso anterior llama a strip(). Recortar modifica la entrada y debe ser una política separada y documentada.
• Las barras inversas se comportan de forma extraña: conserva las cadenas crudas de Python para los patrones. El prefijo r evita una capa adicional de interpretación de escapes. Tutorial de expresiones regulares de Python.
• No existe un identificador con formato correcto: la expresión regular comprueba la forma, no la existencia ni la unicidad. Exige esas condiciones por separado, por ejemplo con restricciones de integridad de la base de datos.

Para probar otra sugerencia de IA, sustituye únicamente la cadena del patrón candidato y vuelve a ejecutar las mismas pruebas. Añade un caso de regresión cada vez que encuentres un error. Estas diez entradas no demuestran la corrección para todas las cadenas ni miden el rendimiento con entradas largas.

Conclusión práctica

Trata una expresión regular generada por IA como una propuesta: define el formato, prueba entradas válidas e inválidas y exige que fallen los controles negativos. Conserva las pruebas junto al importador y repítelas tras cambiar el patrón o el prompt, siguiendo un flujo de pruebas continuas.