Trate uma regex gerada por IA como um rascunho, não como uma regra final. Monte uma pequena tabela de testes sintéticos, compare os resultados esperados com as correspondências reais, revise o padrão e salve um relatório de revisão antes de usá-lo em dados reais.
A tradução foi feita com IA. Confira o código, as unidades e os valores junto com o original. A revisão por falantes nativos de cada idioma ainda não foi concluída. English
Para quem éEste guia é para quem usa IA para criar rascunhos de expressões regulares e quer uma forma simples de testar o padrão com casos conhecidos que devem ou não corresponder.
Suponha que um ID interno de trabalho precise seguir o formato WK-YYYY-NNNN. O prefixo deve ser WK em maiúsculas, o ano deve estar entre 2000 e 2099, os separadores devem ser hífens e a parte final deve conter exatamente quatro dígitos ASCII.
Imagine que um assistente de IA proponha o padrão WK-\d{4}-\d{4}. Ele parece plausível, mas exige apenas quatro dígitos para o ano. Não impõe o intervalo declarado de 2000-2099. O próximo passo mais seguro não é usá-lo imediatamente, mas testá-lo com exemplos cujas respostas já são conhecidas.
O conjunto de dados a seguir é sintético e foi criado especificamente para este artigo. Salve-o como regex_cases.csv. Ele contém três strings que devem corresponder e sete que não devem.
case_id,value,should_match
C001,WK-2026-0001,yes
C002,WK-2000-0042,yes
C003,WK-2099-9999,yes
C004,WK-1999-0001,no
C005,wk-2026-0001,no
C006,WK-2026-001,no
C007,WK-2026-00001,no
C008,WK-2026_0001,no
C009," WK-2026-0001",no
C010,WK-20A6-0001,no
Os casos cobrem os limites permitidos do ano, um ano fora da faixa, prefixo em minúsculas, campos de sequência curtos e longos, separador incorreto, espaço em branco no início e um caractere não numérico no ano. São pequenos o suficiente para serem classificados manualmente antes de executar qualquer regex.
O padrão de IA WK-\d{4}-\d{4} deve aceitar C001, C002 e C003. Por motivos estruturais, deve rejeitar C005 até C010. No entanto, ele também aceita C004 porque 1999 ainda é composto por quatro dígitos.
| Caso | Esperado | Padrão da IA | Resultado |
|---|---|---|---|
| C001 | MATCH | MATCH | PASS |
| C002 | MATCH | MATCH | PASS |
| C003 | MATCH | MATCH | PASS |
| C004 | NO MATCH | MATCH | FAIL |
| C005 | NO MATCH | NO MATCH | PASS |
| C006 | NO MATCH | NO MATCH | PASS |
| C007 | NO MATCH | NO MATCH | PASS |
| C008 | NO MATCH | NO MATCH | PASS |
| C009 | NO MATCH | NO MATCH | PASS |
| C010 | NO MATCH | NO MATCH | PASS |
O padrão revisado é WK-20[0-9]{2}-[0-9]{4}. O prefixo 20 restringe o ano ao intervalo de 2000 a 2099, e [0-9] torna explícito o conjunto de dígitos pretendido. O script usa fullmatch, então toda a string de entrada precisa satisfazer o padrão.
Salve o script a seguir como ai_regex_check.py. Ele testa tanto a proposta da IA quanto o padrão revisado, grava todos os casos em um relatório CSV e se recusa a reutilizar uma pasta de saída existente.
import csv
import re
from pathlib import Path
SOURCE = Path("regex_cases.csv")
OUTPUT_DIR = Path("outputs") / "regex_check_result"
REPORT = OUTPUT_DIR / "regex_check.csv"
AI_PATTERN = re.compile(r"WK-\d{4}-\d{4}")
REVISED_PATTERN = re.compile(r"WK-20[0-9]{2}-[0-9]{4}")
def parse_expected(value: str) -> bool:
normalized = value.strip().lower()
if normalized == "yes":
return True
if normalized == "no":
return False
raise ValueError(f"Expected yes or no, got: {value!r}")
def label(value: bool) -> str:
return "MATCH" if value else "NO MATCH"
def main() -> None:
if not SOURCE.is_file():
raise FileNotFoundError(f"Source CSV not found: {SOURCE}")
if OUTPUT_DIR.exists():
raise FileExistsError(f"Output folder already exists: {OUTPUT_DIR}")
results = []
ai_failures = 0
revised_failures = 0
with SOURCE.open("r", encoding="utf-8-sig", newline="") as stream:
reader = csv.DictReader(stream)
required = {"case_id", "value", "should_match"}
if reader.fieldnames is None or not required.issubset(reader.fieldnames):
raise ValueError("CSV is missing a required column.")
for row_number, row in enumerate(reader, start=2):
expected = parse_expected(row["should_match"])
text = row["value"]
ai_actual = AI_PATTERN.fullmatch(text) is not None
revised_actual = REVISED_PATTERN.fullmatch(text) is not None
ai_pass = ai_actual == expected
revised_pass = revised_actual == expected
if not ai_pass:
ai_failures += 1
if not revised_pass:
revised_failures += 1
results.append({
"case_id": row["case_id"],
"value": text,
"expected": label(expected),
"ai_actual": label(ai_actual),
"ai_test": "PASS" if ai_pass else "FAIL",
"revised_actual": label(revised_actual),
"revised_test": "PASS" if revised_pass else "FAIL",
})
OUTPUT_DIR.parent.mkdir(parents=True, exist_ok=True)
OUTPUT_DIR.mkdir()
fields = [
"case_id", "value", "expected", "ai_actual", "ai_test",
"revised_actual", "revised_test"
]
with REPORT.open("x", encoding="utf-8", newline="") as stream:
writer = csv.DictWriter(stream, fieldnames=fields)
writer.writeheader()
writer.writerows(results)
print(f"Cases: {len(results)}.")
print(f"AI pattern failures: {ai_failures}.")
print(f"Revised pattern failures: {revised_failures}.")
print(f"Report: {REPORT.as_posix()}")
if revised_failures:
raise RuntimeError("Revised pattern still fails one or more tests.")
if __name__ == "__main__":
main()
python ai_regex_check.pyHá 10 casos de teste. O padrão de IA deve falhar em exatamente um caso, C004. O padrão revisado deve passar nos 10 casos.
| Medida | Valor esperado |
|---|---|
| Casos | 10 |
| Falhas do padrão da IA | 1 |
| Falhas do padrão revisado | 0 |
| Caso de falha da IA | C004 |
| Casos aprovados pelo padrão revisado | 10 |
A saída esperada do console abaixo foi derivada manualmente a partir da tabela de testes e do script. Não é um log capturado de execução.
Cases: 10.
AI pattern failures: 1.
Revised pattern failures: 0.
Report: outputs/regex_check_result/regex_check.csv| Erro | Por que isso importa |
|---|---|
| Testar apenas strings que devem corresponder | Uma regex permissiva demais pode parecer correta até que um exemplo negativo seja testado. |
| Usar um padrão de IA sem reformular o requisito | O padrão pode resolver um problema ligeiramente diferente daquele que você pretendia. |
| Verificar apenas um exemplo normal | Erros de limite, comprimento, uso de maiúsculas e minúsculas e separadores continuam sem teste. |
| Usar search em vez de fullmatch para uma regra de campo inteiro | Uma substring aparentemente válida pode ser encontrada dentro de um valor que, como um todo, é inválido. |
| Alterar as respostas esperadas depois de ver a saída da regex | O teste deixa de funcionar como uma especificação independente do comportamento exigido. |
Passar nesses 10 testes mostra apenas que o padrão revisado se comporta corretamente nesses 10 exemplos sintéticos. Isso não prova matematicamente que toda entrada possível será tratada corretamente. Adicione casos sempre que um novo limite ou modo de falha for descoberto.
Uma regex também valida sintaxe, não a verdade do negócio. WK-2026-1234 pode corresponder perfeitamente mesmo que esse ID não exista no seu banco de dados. Existência, unicidade, autorização e relações com outros campos exigem verificações separadas.
Este pequeno exemplo não avalia o desempenho com entradas muito longas ou adversariais. Padrões mais complexos gerados por IA devem ser revisados quanto à correção e ao comportamento em tempo de execução antes de serem colocados em serviços que processam texto não confiável.
2026-09-20 · exemplo verificado manualmente · alvo: Python 3.12 · biblioteca padrão: csv, pathlib, re · sem execução
As explicações e os exemplos são de elaboração própria. Os comportamentos e conceitos relacionados podem ser consultados nas fontes oficiais abaixo.