Arquitecto de automatización con IA: Día 25

# Importaciones base, semilla de la serie, zonas horarias y supuestos del día en Python:
import warnings
warnings.filterwarnings('ignore')
import copy
import difflib
import json
import math
import re
from datetime import date, datetime, timedelta, timezone
from pathlib import Path
from zoneinfo import ZoneInfo
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 120)
carpeta = Path('trigo_lento') / 'dia_25'
flujos = carpeta / 'flujos' / 'make'
flujos.mkdir(parents = True, exist_ok = True)

# Las dos zonas del día y los supuestos de coste (revisado en octubre de 2026):
CDMX = ZoneInfo('America/Mexico_City')
UTC = timezone.utc
CUOTA_CORE = 10_000                         # créditos al mes de Make Core
USD_POR_CREDITO = 10.59 / CUOTA_CORE        # pago mensual de Core repartido entre sus créditos
PEDIDOS_WHATSAPP_MES = round(0.55 * 468)    # el 55 % de los 468 encargos llega por WhatsApp
print('numpy', np.__version__, '| pandas', pd.__version__)
print(f'Pedidos de WhatsApp al mes: {PEDIDOS_WHATSAPP_MES} | USD por crédito: {USD_POR_CREDITO:.6f}')

# Funciones de Make emuladas en Python frente a su equivalente ingenuo:
def make_round(x):                          # Make redondea las mitades hacia arriba
    return math.floor(x + 0.5)

def make_parse_number(texto, separador_decimal):
    limpio = re.sub(r'[^\d' + re.escape(separador_decimal) + '-]', '', texto)
    return float(limpio.replace(separador_decimal, '.'))

def make_get(arreglo, indice):              # Make cuenta desde 1
    return arreglo[indice - 1]

def intentar(funcion):
    try:
        return funcion()
    except Exception as error:
        return f'error ({type(error).__name__})'

renglones = [{'clave': 'P01', 'cantidad': 2}, {'clave': 'P12', 'cantidad': 1}]
claves = [r['clave'] for r in renglones]
instante = datetime(2026, 2, 21, 5, 30, tzinfo = UTC)   # 20 de febrero, 23:30 en la Ciudad de México
casos = [
    ('lower', 'lower("Pal SÁBADO")', lambda: 'Pal SÁBADO'.lower(), lambda: 'Pal SÁBADO'.lower()),
    ('trim', 'trim("  2 hogazas ")', lambda: '  2 hogazas '.strip(), lambda: '  2 hogazas '.strip()),
    ('replace', 'replace("55-0000-0012"; /\\D/g; "")', lambda: re.sub(r'\D', '', '55-0000-0012'),
     lambda: '55-0000-0012'.replace('-', '')),
    ('parseNumber', 'parseNumber("1 140,50"; ",")', lambda: make_parse_number('1 140,50', ','),
     lambda: float('1 140,50')),
    ('round', 'round(2.5)', lambda: make_round(2.5), lambda: round(2.5)),
    ('formatDate', 'formatDate(t; "YYYY-MM-DD"; zona)', lambda: instante.astimezone(CDMX).strftime('%Y-%m-%d'),
     lambda: instante.strftime('%Y-%m-%d')),
    ('parseDate', 'parseDate("21/02/2026"; "DD/MM/YYYY")',
     lambda: datetime.strptime('21/02/2026', '%d/%m/%Y').date().isoformat(),
     lambda: datetime.strptime('21/02/2026', '%d/%m/%Y').date().isoformat()),
    ('addDays', 'addDays(2026-02-20; 1)', lambda: (date(2026, 2, 20) + timedelta(days = 1)).isoformat(),
     lambda: (date(2026, 2, 20) + timedelta(days = 1)).isoformat()),
    ('map', 'map(renglones; "clave")', lambda: [r['clave'] for r in renglones],
     lambda: [r['clave'] for r in renglones]),
    ('get', 'get(claves; 1)', lambda: make_get(claves, 1), lambda: claves[1]),
    ('length', 'length(claves)', lambda: len(claves), lambda: len(claves)),
    ('join', 'join(claves; ", ")', lambda: ', '.join(claves), lambda: ', '.join(claves)),
]
tabla_funciones = pd.DataFrame([{'función': f, 'ejemplo en Make': ej, 'Make': str(intentar(m)),
                                 'Python ingenuo': str(intentar(p))} for f, ej, m, p in casos])
tabla_funciones['coinciden'] = np.where(tabla_funciones['Make'] == tabla_funciones['Python ingenuo'], 'sí', 'NO')
print(tabla_funciones.to_string(index = False))
print('Coinciden', (tabla_funciones['coinciden'] == 'sí').sum(), 'de', len(tabla_funciones))

# Equivalentes de formatDate, parseDate, addDays y setDay contra los ejemplos de la documentación de Make:
FICHAS = {'YYYY': '%Y', 'MM': '%m', 'DD': '%d', 'HH': '%H', 'hh': '%I', 'mm': '%M', 'ss': '%S', 'A': '%p'}
PATRON_FICHAS = re.compile('|'.join(sorted(FICHAS, key = len, reverse = True)))
DIAS_INGLES = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday']

def a_strftime(formato):
    return PATRON_FICHAS.sub(lambda m: FICHAS[m.group(0)], formato)

def format_date(t, formato, zona = None, zona_org = 'UTC'):
    # Sin zona explícita, Make usa la zona de la organización:
    return t.astimezone(ZoneInfo(zona or zona_org)).strftime(a_strftime(formato))

def parse_date(texto, formato, zona = None, zona_org = 'UTC'):
    if formato == 'X':                       # segundos desde 1970
        return datetime.fromtimestamp(int(texto), UTC)
    local = datetime.strptime(texto, a_strftime(formato)).replace(tzinfo = ZoneInfo(zona or zona_org))
    return local.astimezone(UTC)

def add_days(t, n):
    return t + timedelta(days = n)

def set_day(t, dia):                         # 1 = domingo ... 7 = sábado, semana de domingo a sábado
    if isinstance(dia, str):
        dia = DIAS_INGLES.index(dia.lower()) + 1
    actual = (t.weekday() + 1) % 7 + 1       # Python cuenta lunes = 0
    return t + timedelta(days = dia - actual)

def iso(t):
    return t.astimezone(UTC).strftime('%Y-%m-%dT%H:%M:%SZ')

t1 = datetime(2018, 10, 1, 7, 32, tzinfo = UTC)
t2 = datetime(2016, 12, 8, 15, 55, 57, tzinfo = UTC)
t3 = datetime(2018, 6, 27, 11, 36, 39, tzinfo = UTC)
pruebas = [
    ('parseDate(2016-12-28; YYYY-MM-DD)', iso(parse_date('2016-12-28', 'YYYY-MM-DD')), '2016-12-28T00:00:00Z'),
    ('parseDate(2016-12-28 16:03; YYYY-MM-DD HH:mm)', iso(parse_date('2016-12-28 16:03', 'YYYY-MM-DD HH:mm')),
     '2016-12-28T16:03:00Z'),
    ('parseDate(1482940986; X)', iso(parse_date('1482940986', 'X')), '2016-12-28T16:03:06Z'),
    ('formatDate(t; DD.MM.YYYY HH:mm; UTC)', format_date(t1, 'DD.MM.YYYY HH:mm', 'UTC'), '01.10.2018 07:32'),
    ('formatDate(t; YYYY-MM-DD hh:mm A), Praga', format_date(t1, 'YYYY-MM-DD hh:mm A', zona_org = 'Europe/Prague'),
     '2018-10-01 09:32 AM'),
    ('formatDate(t; MM/DD/YYYY), Praga', format_date(t1, 'MM/DD/YYYY', zona_org = 'Europe/Prague'), '10/01/2018'),
    ('addDays(2016-12-08T15:55:57Z; 2)', iso(add_days(t2, 2)), '2016-12-10T15:55:57Z'),
    ('addDays(2016-12-08T15:55:57Z; -2)', iso(add_days(t2, -2)), '2016-12-06T15:55:57Z'),
    ('setDay(2018-06-27T11:36:39Z; monday)', iso(set_day(t3, 'monday')), '2018-06-25T11:36:39Z'),
    ('setDay(2018-06-27T11:36:39Z; 1)', iso(set_day(t3, 1)), '2018-06-24T11:36:39Z'),
    ('setDay(2018-06-27T11:36:39Z; 7)', iso(set_day(t3, 7)), '2018-06-30T11:36:39Z'),
]
for nombre, obtenido, esperado in pruebas:
    print(f"{'ok ' if obtenido == esperado else 'MAL'} {nombre:<45} -> {obtenido}")
print('Casos que coinciden con la documentación:', sum(o == e for _, o, e in pruebas), 'de', len(pruebas))

# La fecha "21/02/2026" leída sin zona en una organización en UTC y mostrada en el obrador:
sin_zona = parse_date('21/02/2026', 'DD/MM/YYYY')
con_zona = parse_date('21/02/2026', 'DD/MM/YYYY', zona = 'America/Mexico_City')
print('Sin zona:', iso(sin_zona), '->', format_date(sin_zona, 'YYYY-MM-DD', 'America/Mexico_City'), 'en el obrador')
print('Con zona:', iso(con_zona), '->', format_date(con_zona, 'YYYY-MM-DD', 'America/Mexico_City'), 'en el obrador')

# La misma hora en dos relojes: Ciudad de México y UTC con zoneinfo en Python:
DIAS = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

def proximo(dia_semana, hoy):                # el próximo <día> que no sea hoy
    dias = (dia_semana - hoy.weekday()) % 7
    return hoy + timedelta(days = dias or 7)

def interpretar_relativa(expresion, recibido, zona):
    hoy = recibido.astimezone(zona).date()   # "hoy" depende del reloj que se consulte
    if expresion.endswith('hoy'):
        return hoy
    if expresion.endswith('mañana'):
        return hoy + timedelta(days = 1)
    return proximo(DIAS.index(expresion.split()[-1]), hoy)

mensajes = [(datetime(2026, 2, 20, 23, 30, tzinfo = CDMX), 'pal sábado'),
            (datetime(2026, 2, 20, 17, 59, tzinfo = CDMX), 'pal sábado'),
            (datetime(2026, 2, 20, 18, 0, tzinfo = CDMX), 'para mañana'),
            (datetime(2026, 2, 21, 9, 15, tzinfo = CDMX), 'para hoy'),
            (datetime(2026, 2, 21, 19, 40, tzinfo = CDMX), 'pal lunes'),
            (datetime(2026, 2, 25, 20, 10, tzinfo = CDMX), 'para mañana')]
filas = []
for recibido, expresion in mensajes:
    bien = interpretar_relativa(expresion, recibido, CDMX)
    mal = interpretar_relativa(expresion, recibido, UTC)
    en_utc = recibido.astimezone(UTC)
    filas.append({'recibido (CDMX)': f"{DIAS[recibido.weekday()][:3]} {recibido:%d %H:%M}",
                  'en UTC': f"{DIAS[en_utc.weekday()][:3]} {en_utc:%d %H:%M}", 'mensaje': expresion,
                  'entrega CDMX': bien.isoformat(), 'entrega UTC': mal.isoformat(), 'error (días)': (mal - bien).days})
print(pd.DataFrame(filas).to_string(index = False))

# Desfase de la Ciudad de México frente a UTC antes y después de octubre de 2022:
for f in [datetime(2021, 7, 1, 12), datetime(2022, 7, 1, 12), datetime(2022, 11, 1, 12),
          datetime(2026, 2, 20, 12), datetime(2026, 7, 1, 12)]:
    print(f.date(), 'UTC', f'{f.replace(tzinfo = CDMX).utcoffset().total_seconds() / 3600:+.0f} h')

# Desde qué hora local la fecha en UTC ya es la de mañana:
umbral = next(h for h in range(24) if datetime(2026, 2, 20, h, tzinfo = CDMX).astimezone(UTC).day == 21)
print(f'Desde las {umbral}:00 de la Ciudad de México, la fecha en UTC ya es la del día siguiente')

# Iterador y agregador simulados: créditos por pedido y por mes en Python:
DISENOS = {
    'A. Formulario estructurado, sin iterador': ['webhook', 'variables', 'fila', 'respuesta'],
    'B. Iterador y agregador (v2.1)': ['webhook', 'respuesta', 'router', 'catalogo', 'preparar', 'iterador',
                                       'renglon', 'agregador', 'normalizar', 'router', 'fila'],
    'C. Iterador sin agregador': ['webhook', 'respuesta', 'router', 'catalogo', 'preparar', 'iterador',
                                  'renglon', 'fila'],
}

def creditos_por_pedido(modulos, n, agregador_por_entrada = False):
    paquetes, creditos = 1, 0
    for m in modulos:
        if m == 'router':
            continue                                   # routers y filtros no cobran
        if m == 'agregador':
            creditos += paquetes if agregador_por_entrada else 1
            paquetes = 1                               # junta los n paquetes en uno
            continue
        creditos += paquetes                           # una operación por paquete recibido
        if m == 'iterador':
            paquetes *= n                              # parte el arreglo en n paquetes
    return creditos

n = np.arange(1, 13)
curvas = {d: np.array([creditos_por_pedido(m, k) for k in n]) for d, m in DISENOS.items()}
for d, c in curvas.items():
    print(f'{d:<42} n=1: {c[0]:>2} | n=3: {c[2]:>2} | n=12: {c[11]:>2}')
print('Si el agregador cobrara por paquete recibido, B con n=3:',
      creditos_por_pedido(DISENOS['B. Iterador y agregador (v2.1)'], 3, agregador_por_entrada = True))

# 2 000 meses simulados: Poisson(257) pedidos y 1 + Poisson(0.54) renglones por pedido:
MESES, EXTRA = 2_000, 0.54
mes_b, mes_c = np.zeros(MESES), np.zeros(MESES)
for i in range(MESES):
    r = 1 + rng.poisson(EXTRA, rng.poisson(PEDIDOS_WHATSAPP_MES))
    mes_b[i], mes_c[i] = (8 + r).sum(), (5 + 2 * r).sum()
for nombre, mes, teorico in [('B', mes_b, PEDIDOS_WHATSAPP_MES * (8 + 1 + EXTRA)),
                             ('C', mes_c, PEDIDOS_WHATSAPP_MES * (5 + 2 * (1 + EXTRA)))]:
    print(f'{nombre}: media {mes.mean():7.1f} (teórico {teorico:.1f}) | p95 {np.percentile(mes, 95):5.0f} | '
          f'{mes.mean() / CUOTA_CORE:.2%} de Core | {mes.mean() * USD_POR_CREDITO:.2f} USD')

fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (12, 4.6))
colores = ['#8a8986', '#2a78d6', '#eb6834']
for (d, c), color in zip(curvas.items(), colores):
    ax1.plot(n, c, marker = 'o', ms = 4, lw = 2, color = color, label = d)
ax1.axvline(3, color = '#52514e', ls = ':', lw = 1)
ax1.text(3.25, 6.2, 'B y C empatan\ncon 3 renglones', fontsize = 9, color = '#52514e')
ax1.set_xlabel('Renglones del pedido')
ax1.set_ylabel('Créditos por pedido')
ax1.set_title('Créditos de un pedido', fontsize = 12)
ax1.legend(fontsize = 8.5, loc = 'upper left')
ax1.grid(color = '#e6e5e1')
bins = np.arange(1700, 2900, 20)
ax2.hist(mes_b, bins = bins, color = '#2a78d6', alpha = 0.8, label = 'B. Iterador y agregador')
ax2.hist(mes_c, bins = bins, color = '#eb6834', alpha = 0.8, label = 'C. Sin agregador')
ax2.set_xlabel('Créditos de la ruta de pedidos en un mes')
ax2.set_ylabel('Meses simulados')
ax2.set_title('2 000 meses de 257 pedidos en promedio', fontsize = 12)
ax2.legend(fontsize = 9)
fig.suptitle('Iterar y agregar: lo que cuesta cada renglón', fontsize = 16)
plt.tight_layout()
plt.show()

{
  "name": "TL Pedidos WhatsApp v2.1 (fragmento: módulos 5 a 7 de la ruta de pedidos)",
  "flow": [
    {
      "id": 5,
      "module": "builtin:BasicFeeder",
      "version": 1,
      "parameters": {},
      "mapper": {"array": "{{4.partes}}"},
      "metadata": {"designer": {"x": 1500, "y": 150}}
    },
    {
      "id": 6,
      "module": "util:SetVariables",
      "version": 1,
      "parameters": {},
      "mapper": {
        "variables": [
          {"name": "cantidad", "value": "{{ifempty(parseNumber(replace(5.value; /^.*?\\b(\\d+)\\s.*$/; \"$1\"); \".\"); get(4.cantidades; replace(5.value; /^.*?\\b(media docena|una docena|una|un|dos|tres)\\s.*$/; \"$1\")))}}"},
          {"name": "producto", "value": "{{trim(replace(5.value; /^.*?\\b(\\d+|media docena|una docena|una|un|dos|tres)\\s+(de\\s+)?/; emptystring))}}"},
          {"name": "clave", "value": "{{get(4.alias; trim(replace(5.value; /^.*?\\b(\\d+|media docena|una docena|una|un|dos|tres)\\s+(de\\s+)?/; emptystring)))}}"},
          {"name": "importe_centavos", "value": "{{(ifempty(parseNumber(replace(5.value; /^.*?\\b(\\d+)\\s.*$/; \"$1\"); \".\"); get(4.cantidades; replace(5.value; /^.*?\\b(media docena|una docena|una|un|dos|tres)\\s.*$/; \"$1\")))) * get(4.precios_centavos; get(4.alias; trim(replace(5.value; /^.*?\\b(\\d+|media docena|una docena|una|un|dos|tres)\\s+(de\\s+)?/; emptystring))))}}"}
        ],
        "scope": "roundtrip"
      },
      "metadata": {"designer": {"x": 1800, "y": 150}}
    },
    {
      "id": 7,
      "module": "builtin:BasicAggregator",
      "version": 1,
      "parameters": {"feeder": 5},
      "filter": {
        "name": "Es renglón",
        "conditions": [[{"a": "{{6.cantidad}}", "o": "exist"}]]
      },
      "mapper": {
        "clave": "{{6.clave}}",
        "producto": "{{6.producto}}",
        "cantidad": "{{6.cantidad}}",
        "importe_centavos": "{{6.importe_centavos}}"
      },
      "metadata": {"designer": {"x": 2100, "y": 150}}
    }
  ]
}

# Normalización de 200 pedidos de WhatsApp con las reglas de la v2.1 en Python:
CATALOGO = {'P01': 95, 'P02': 38, 'P03': 72, 'P04': 22, 'P05': 34, 'P06': 38,
            'P07': 60, 'P08': 420, 'P09': 460, 'P10': 240, 'P11': 66, 'P12': 380}
ALIAS = {'hogaza': 'P01', 'hogazas': 'P01', 'baguette': 'P02', 'baguettes': 'P02', 'pan de caja': 'P03',
         'panes de caja': 'P03', 'concha': 'P04', 'conchas': 'P04', 'croissant': 'P05', 'croissants': 'P05',
         'cuernitos': 'P05', 'rol de canela': 'P06', 'roles de canela': 'P06', 'paquete de galletas': 'P07',
         'paquetes de galletas': 'P07', 'pastel de zanahoria': 'P08', 'pastel de chocolate': 'P09',
         'caja de pan dulce': 'P10', 'cajas de pan dulce': 'P10', 'paquete de bollos': 'P11',
         'paquetes de bollos': 'P11', 'pay de queso': 'P12', 'pays de queso': 'P12'}
ERRATAS = ['hogasa', 'crosant', 'baget', 'pay de keso', 'rol de canel', 'conhas']
CANTIDADES = {'un': 1, 'una': 1, 'dos': 2, 'tres': 3, 'media docena': 6, 'una docena': 12}
PATRON_CANTIDAD = re.compile(r'^.*?\b(\d+|media docena|una docena|una|un|dos|tres)\s+(?:de\s+)?')
COLA_FECHA = re.compile(r'\s+(?:pal|pa|para el|para|el|mañana|hoy|la otra semana|cuando|en la semana)\b.*$')

def normalizar_telefono(wa_id):
    m = re.fullmatch(r'52(1)?(\d{10})', re.sub(r'\D', '', wa_id))
    return '+52' + m.group(2) if m else None

def extraer_renglones(texto, alias = ALIAS):
    partes = re.split(r',|\s+y\s+', COLA_FECHA.sub('', texto.lower().strip()))
    salida = []
    for parte in partes:                               # el iterador: un paquete por parte
        m = PATRON_CANTIDAD.match(parte)
        if not m:
            continue                                   # filtro "Es renglón": sin cantidad no es renglón
        cantidad = int(m.group(1)) if m.group(1).isdigit() else CANTIDADES[m.group(1)]
        producto = parte[m.end():].strip()
        salida.append({'producto': producto, 'clave': alias.get(producto), 'cantidad': cantidad})
    return salida                                      # el agregador: el arreglo reconstruido

def interpretar_fecha(texto, recibido, zona):
    hoy, t = recibido.astimezone(zona).date(), texto.lower()
    if m := re.search(r'\b(\d{1,2})/(\d{1,2})(?:/(\d{4}))?\b', t):
        fecha = date(int(m.group(3) or hoy.year), int(m.group(2)), int(m.group(1)))
    elif re.search(r'\bmañana\b', t):
        fecha = hoy + timedelta(days = 1)
    elif re.search(r'\bhoy\b', t):
        fecha = hoy
    elif dia := next((d for d in DIAS if re.search(rf'\b{d}\b', t)), None):
        fecha = proximo(DIAS.index(dia), hoy)
    elif m := re.search(r'\bel (\d{1,2})\b', t):
        d = int(m.group(1))
        fecha = date(hoy.year, hoy.month, d) if d >= hoy.day else date(hoy.year, hoy.month + 1, d)
    else:
        return None, 'sin fecha reconocible'
    if fecha < hoy:
        return None, 'fecha pasada'
    if fecha.weekday() == 6:
        return None, 'domingo: cerrado'
    return fecha, 'ok'

# 200 pedidos de juguete con la forma de los mensajes reales (semilla 2026):
HORAS = np.arange(7, 24)
PESOS_HORA = np.array([2, 4, 6, 9, 9, 7, 5, 4, 4, 4, 4, 5, 6, 6, 4, 2, 1], dtype = float)
FORMAS_FECHA = ['semana', 'mañana', 'hoy', 'explicita', 'dia_mes', 'ambigua', 'sin']
PROB_FECHA = [0.28, 0.20, 0.05, 0.20, 0.10, 0.12, 0.05]
claves_alias = list(ALIAS)
pedidos = []
for i in range(200):
    recibido = datetime(2026, 2, 16 + int(rng.integers(0, 6)), int(rng.choice(HORAS, p = PESOS_HORA / PESOS_HORA.sum())),
                        int(rng.integers(0, 60)), tzinfo = CDMX)
    hoy = recibido.date()
    partes = []
    for _ in range(1 + min(rng.poisson(EXTRA), 3)):
        producto = str(rng.choice(ERRATAS)) if rng.random() < 0.08 else str(rng.choice(claves_alias))
        cantidad = str(rng.choice(['1', '2', '3', '4', 'una', 'dos', 'media docena de']))
        partes.append(f'{cantidad} {producto}')
    forma = rng.choice(FORMAS_FECHA, p = PROB_FECHA)
    if forma == 'semana':
        expresion = f"{rng.choice(['pal', 'para el', 'el'])} {rng.choice(DIAS, p = [.16, .16, .16, .16, .16, .16, .04])}"
    elif forma == 'mañana':
        expresion = str(rng.choice(['pa mañana', 'para mañana', 'mañana']))
    elif forma == 'hoy':
        expresion = 'para hoy'
    elif forma == 'explicita':
        f = hoy + timedelta(days = int(rng.integers(1, 9)))
        expresion = f'para el {f.day:02d}/{f.month:02d}'
    elif forma == 'dia_mes':
        expresion = f'el {(hoy + timedelta(days = int(rng.integers(1, 11)))).day}'
    elif forma == 'ambigua':
        expresion = str(rng.choice(['la otra semana', 'cuando esté listo', 'en la semana', 'para el cumple de mi mamá']))
    else:
        expresion = ''
    texto = (str(rng.choice(['hola, me aparta ', 'buenas tardes, quiero ', 'hola! me guarda ', 'quisiera ', '']))
             + ' y '.join(partes) + (' ' + expresion if expresion else '')
             + str(rng.choice(['', ', soy Lucía', ', gracias', ' porfa'])))
    sufijo = f'{i % 100:02d}'
    wa_id = rng.choice(['521550000' + '00' + sufijo, '52550000' + '00' + sufijo, '1555000' + '00' + sufijo],
                       p = [0.70, 0.25, 0.05])
    pedidos.append({'recibido': recibido, 'wa_id': str(wa_id), 'texto': texto, 'forma': forma})

def normalizar(p, alias = ALIAS, zona = CDMX):
    telefono = normalizar_telefono(p['wa_id'])
    renglones_p = extraer_renglones(p['texto'], alias)
    productos_ok = bool(renglones_p) and all(r['clave'] for r in renglones_p)
    fecha, motivo = interpretar_fecha(p['texto'], p['recibido'], zona)
    total = sum(r['cantidad'] * CATALOGO[r['clave']] * 100 for r in renglones_p) if productos_ok else None
    return {'telefono': telefono, 'productos': productos_ok, 'fecha_entrega': fecha, 'motivo_fecha': motivo,
            'total_centavos': total, 'renglones': len(renglones_p)}

resultados = pd.DataFrame([normalizar(p) for p in pedidos])
resultados['fecha_utc'] = [interpretar_fecha(p['texto'], p['recibido'], UTC)[0] for p in pedidos]
resultados['hora'] = [p['recibido'].hour for p in pedidos]
resultados['forma'] = [p['forma'] for p in pedidos]
campos = {'telefono': resultados['telefono'].notna(), 'productos': resultados['productos'],
          'fecha_entrega': resultados['fecha_entrega'].notna(), 'total_centavos': resultados['total_centavos'].notna()}
resultados['completo'] = np.logical_and.reduce(list(campos.values()))
tabla3 = pd.DataFrame([{'campo': c, 'normalizados': int(ok.sum()), 'a revisión': int((~ok).sum()),
                        'tasa': f'{ok.mean():.1%}'} for c, ok in campos.items()])
print(tabla3.to_string(index = False))
print('Pedidos completos:', int(resultados['completo'].sum()), 'de 200 | a revisión:', int((~resultados['completo']).sum()))
print('Motivos de fecha:', resultados['motivo_fecha'].value_counts().to_dict())
print('Renglones por pedido: media', round(resultados['renglones'].mean(), 2),
      '| con un solo renglón:', f"{(resultados['renglones'] == 1).mean():.0%}")
relativas = resultados['forma'].isin(['semana', 'mañana', 'hoy'])
error_utc = resultados['fecha_entrega'].notna() & (resultados['fecha_utc'] != resultados['fecha_entrega'])
print('Con el reloj en UTC cambiarían de fecha:', int(error_utc.sum()), 'pedidos; todos recibidos desde las',
      int(resultados.loc[error_utc, 'hora'].min()), 'h, de', int((relativas & (resultados['hora'] >= 18)).sum()),
      'relativos llegados desde las 18 h')
print('Ejemplo:', pedidos[0]['texto'], '->', normalizar(pedidos[0])['fecha_entrega'], normalizar(pedidos[0])['total_centavos'])

fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (12, 4.6))
tasas = [ok.mean() * 100 for ok in campos.values()] + [resultados['completo'].mean() * 100]
etiquetas = list(campos) + ['pedido completo']
barras = ax1.barh(etiquetas[::-1], tasas[::-1], color = ['#3a9d5d'] + ['#2a78d6'] * 4)
for b, v in zip(barras, tasas[::-1]):
    ax1.text(v - 1, b.get_y() + b.get_height() / 2, f'{v:.1f} %', va = 'center', ha = 'right', color = 'white', fontsize = 10)
ax1.set_xlim(0, 100)
ax1.set_xlabel('% de los 200 pedidos normalizados sin intervención')
ax1.set_title('Tasa de normalización por campo', fontsize = 12)
horas = np.arange(7, 24)
rel_por_hora = [int((relativas & (resultados['hora'] == h)).sum()) for h in horas]
err_por_hora = [int((error_utc & (resultados['hora'] == h)).sum()) for h in horas]
ax2.bar(horas, rel_por_hora, color = '#2a78d6', label = 'Pedidos con fecha relativa')
ax2.bar(horas, err_por_hora, color = '#c8423b', label = 'Fecha distinta si el reloj está en UTC')
ax2.axvline(17.5, color = '#52514e', ls = ':', lw = 1)
ax2.text(17.7, max(rel_por_hora) * 0.92, '18:00 en la Ciudad de México\n= 00:00 en UTC', fontsize = 9, color = '#52514e')
ax2.set_xlabel('Hora de llegada (Ciudad de México)')
ax2.set_ylabel('Pedidos')
ax2.set_title('Dónde se equivoca un reloj en UTC', fontsize = 12)
ax2.legend(fontsize = 9, loc = 'upper left')
fig.suptitle('Normalizar 200 pedidos de WhatsApp con reglas', fontsize = 16)
plt.tight_layout()
plt.show()

# Reglas, módulo de código o modelo de lenguaje: cobertura, coste y latencia en Python:
def alias_difuso(producto):
    parecido = difflib.get_close_matches(producto, claves_alias, n = 1, cutoff = 0.75)
    return ALIAS[parecido[0]] if parecido else None

class AliasConErratas(dict):                           # el "código": reglas más corrección de erratas
    def get(self, producto, defecto = None):
        return ALIAS.get(producto) or alias_difuso(producto)

con_codigo = pd.DataFrame([normalizar(p, alias = AliasConErratas()) for p in pedidos])
completo_codigo = (con_codigo['telefono'].notna() & con_codigo['productos'] & con_codigo['fecha_entrega'].notna())
q_reglas, q_codigo = resultados['completo'].mean(), completo_codigo.mean()

# Lo que un modelo podría resolver: solo productos dudosos; fecha ambigua, domingo o teléfono extranjero van a una persona:
resoluble_ia = (~resultados['completo']) & resultados['telefono'].notna() & resultados['fecha_entrega'].notna()
PRECISION_IA = 0.97                                    # supuesto declarado, no medido
q_ia = q_reglas + resoluble_ia.mean() * PRECISION_IA
tokens_entrada, tokens_salida = 450, 80
usd_haiku = tokens_entrada * 0.10 / 1e6 + tokens_salida * 0.50 / 1e6
usd_opus = tokens_entrada * 4.00 / 1e6 + tokens_salida * 20.00 / 1e6
USD_VALERIA = 1.5 / 60 * 75 / 18.50                    # 1.5 minutos a 75 MXN la hora
opciones = pd.DataFrame([
    {'opción': 'Reglas (funciones de Make)', 'créditos': 1, 'USD': USD_POR_CREDITO, 'latencia_s': 0.05, 'cobertura': q_reglas},
    {'opción': 'Módulo de código (Make Code)', 'créditos': 2, 'USD': 2 * USD_POR_CREDITO, 'latencia_s': 1.0, 'cobertura': q_codigo},
    {'opción': 'Claude Haiku 5.5 por HTTP', 'créditos': 1, 'USD': USD_POR_CREDITO + usd_haiku, 'latencia_s': 1.5, 'cobertura': q_ia},
    {'opción': 'Claude Opus 5.5 por HTTP', 'créditos': 1, 'USD': USD_POR_CREDITO + usd_opus, 'latencia_s': 6.0, 'cobertura': q_ia},
    {'opción': 'Persona (Valeria)', 'créditos': 0, 'USD': USD_VALERIA, 'latencia_s': 20 * 60, 'cobertura': 1.0},
])
print(opciones.to_string(index = False, formatters = {'USD': '{:.5f}'.format, 'cobertura': '{:.1%}'.format}))

# Cascada: reglas para todos, Haiku para lo dudoso, persona para lo demás, contra dos alternativas puras:
N = PEDIDOS_WHATSAPP_MES
c_r, c_ia = USD_POR_CREDITO, USD_POR_CREDITO + usd_haiku
cascada = N * (c_r + (1 - q_reglas) * c_ia + (1 - q_ia) * USD_VALERIA)
cascada_codigo = N * (c_r + (1 - q_reglas) * 2 * USD_POR_CREDITO + (1 - q_codigo) * USD_VALERIA)
todo_opus = N * ((USD_POR_CREDITO + usd_opus) + (1 - q_ia) * USD_VALERIA)
todo_persona = N * USD_VALERIA
print(f'Al mes ({N} pedidos): todo a mano {todo_persona:.2f} USD | todo con Opus {todo_opus:.2f} USD | '
      f'cascada con Haiku {cascada:.2f} USD | cascada con código {cascada_codigo:.2f} USD')
print('Teléfonos extranjeros:', int(resultados['telefono'].isna().sum()), '| fechas ambiguas o ausentes:',
      int((resultados['motivo_fecha'] == 'sin fecha reconocible').sum()), '| domingos:',
      int((resultados['motivo_fecha'] == 'domingo: cerrado').sum()))
print(f'Mensajes que viajan a un modelo: cascada {round(N * (1 - q_reglas))} de {N}; todo con Opus {N}')
print(f'Minutos de Valeria al mes: a mano {N * 1.5:.0f} | cascada {N * (1 - q_ia) * 1.5:.0f}')

fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (12, 4.6))
nombres = ['Todo a mano', 'Todo con\nOpus 5.5', 'Cascada\ncon Haiku', 'Cascada\ncon código']
make_usd = [0, N * USD_POR_CREDITO, N * (c_r + (1 - q_reglas) * USD_POR_CREDITO),
            N * (c_r + (1 - q_reglas) * 2 * USD_POR_CREDITO)]
claude_usd = [0, N * usd_opus, N * (1 - q_reglas) * usd_haiku, 0]
persona_usd = [todo_persona, N * (1 - q_ia) * USD_VALERIA, N * (1 - q_ia) * USD_VALERIA, N * (1 - q_codigo) * USD_VALERIA]
ax1.bar(nombres, persona_usd, color = '#8a8986', label = 'Tiempo de Valeria')
ax1.bar(nombres, make_usd, bottom = persona_usd, color = '#2a78d6', label = 'Créditos de Make')
ax1.bar(nombres, claude_usd, bottom = np.add(persona_usd, make_usd), color = '#7b5ea7', label = 'API de Claude')
for k, total in enumerate([todo_persona, todo_opus, cascada, cascada_codigo]):
    ax1.text(k, total + 0.4, f'{total:.2f} USD', ha = 'center', fontsize = 10)
ax1.set_ylabel('USD al mes (ilustrativo)')
ax1.set_ylim(0, todo_persona * 1.18)
ax1.set_title(f'Normalizar {N} pedidos al mes', fontsize = 12)
ax1.legend(fontsize = 9)
ax2.barh(opciones['opción'][::-1], opciones['latencia_s'][::-1], color = ['#8a8986', '#7b5ea7', '#7b5ea7', '#2a78d6', '#2a78d6'])
ax2.set_xscale('log')
for y, v in enumerate(opciones['latencia_s'][::-1]):
    ax2.text(v * 1.15, y, f'{v:g} s', va = 'center', fontsize = 9)
ax2.set_xlim(0.02, 1e4)
ax2.set_xlabel('Latencia típica en segundos (escala logarítmica, ilustrativa)')
ax2.set_title('Cuánto espera el pedido', fontsize = 12)
fig.suptitle('Reglas, código o IA: coste y latencia', fontsize = 16)
plt.tight_layout()
plt.show()

# TL Pedidos WhatsApp v2.1: ensamblar el blueprint, validarlo, contar créditos y dibujarlo en Python:
from matplotlib.patches import Ellipse, FancyBboxPatch, Polygon, RegularPolygon, FancyArrowPatch

TIPOS = {'gateway:CustomWebHook': 'disparador', 'builtin:BasicRouter': 'decision'}
FORMAS = {'disparador': ('ovalo', '#3a9d5d'), 'accion': ('rectangulo', '#2a78d6'),
          'decision': ('rombo', '#eb6834'), 'ia': ('rectangulo', '#7b5ea7'),
          'error': ('rectangulo', '#c8423b'), 'humano': ('hexagono', '#8a8986')}

def tipo_de(m):
    if m['mapper'] and m['mapper'].get('sheetId') == 'Revisión':
        return 'humano'                                # la hoja de revisión la atiende una persona
    return TIPOS.get(m['module'], 'accion')

def dibujar_flujo(nodos, aristas, titulo, ax = None, ancho = 2.4, alto = 0.95, recorte = 34):
    if ax is None:
        fig, ax = plt.subplots(figsize = (12, 5.6))
    for nd in nodos:
        forma, color = FORMAS[nd['tipo']]
        x, y = nd['x'], nd['y']
        if forma == 'ovalo':
            figura = Ellipse((x, y), ancho, alto)
        elif forma == 'rombo':
            figura = Polygon([(x - ancho / 2, y), (x, y + alto / 1.3), (x + ancho / 2, y), (x, y - alto / 1.3)])
        elif forma == 'hexagono':
            figura = RegularPolygon((x, y), 6, radius = ancho / 2, orientation = np.pi / 6)
        else:
            figura = FancyBboxPatch((x - ancho / 2, y - alto / 2), ancho, alto, boxstyle = 'round,pad=0.03')
        figura.set_facecolor(color)
        figura.set_edgecolor('white')
        figura.set_linewidth(2)
        ax.add_patch(figura)
        ax.text(x, y, nd['texto'], ha = 'center', va = 'center', fontsize = 7.5, color = 'white')
    posicion = {nd['id']: (nd['x'], nd['y']) for nd in nodos}
    for origen, destino, etiqueta in aristas:
        (x1, y1), (x2, y2) = posicion[origen], posicion[destino]
        ax.add_patch(FancyArrowPatch((x1, y1), (x2, y2), arrowstyle = '-|>', mutation_scale = 14,
                                     shrinkA = recorte, shrinkB = recorte + 2, color = '#52514e', linewidth = 1.4))
        if etiqueta:
            ax.text((x1 + x2) / 2, (y1 + y2) / 2 + 0.3, etiqueta, ha = 'center', fontsize = 8,
                    color = '#52514e', bbox = dict(facecolor = 'white', edgecolor = 'none', pad = 1))
    xs, ys = [nd['x'] for nd in nodos], [nd['y'] for nd in nodos]
    ax.set_xlim(min(xs) - 1.3, max(xs) + 1.3)
    ax.set_ylim(min(ys) - 1.0, max(ys) + 1.0)
    ax.set_aspect('equal')
    ax.axis('off')
    ax.set_title(titulo, fontsize = 12)
    return ax

def nodos_desde_blueprint(bp, escala = 300 / 2.7):
    nodos, aristas = [], []
    def recorrer(flujo, previo, etiqueta, profundidad):
        for m in flujo:
            d = m['metadata']['designer']
            app, accion = m['module'].split(':')
            nodos.append({'id': m['id'], 'tipo': tipo_de(m), 'texto': f"{m['id']} {app}\n{accion}",
                          'x': d['x'] / escala, 'y': -d['y'] / escala, 'profundidad': profundidad})
            if previo is not None:
                aristas.append((previo, m['id'], m.get('filter', {}).get('name', etiqueta)))
            recorrer(m.get('onerror', []), m['id'], 'si falla', profundidad + 1)
            for ruta in m.get('routes', []):
                recorrer(ruta['flow'], m['id'], '', profundidad + 1)
            previo, etiqueta = m['id'], ''
    recorrer(bp['flow'], None, '', 0)
    return nodos, aristas

def modulo(id_, nombre, x, y, mapper = None, version = 1, **extra):
    m = {'id': id_, 'module': nombre, 'version': version, 'parameters': {}, 'mapper': mapper,
         'metadata': {'designer': {'x': x, 'y': y}}}
    m.update(extra)
    return m

def variables(**pares):
    return {'variables': [{'name': k, 'value': v} for k, v in pares.items()], 'scope': 'roundtrip'}

def hoja(id_, nombre_hoja, x, y, valores, **extra):
    mapper = {'mode': 'select', 'spreadsheetId': '/ID_DE_EJEMPLO', 'sheetId': nombre_hoja, 'includesHeaders': True,
              'valueInputOption': 'RAW', 'values': valores}
    return modulo(id_, 'google-sheets:addRow', x, y, mapper, version = 2, parameters = {'__IMTCONN__': 0}, **extra)

fragmento = json.loads((flujos / 'renglones_v2_1.fragmento.json').read_text(encoding = 'utf-8'))['flow']
SIN_FECHA = r'replace(lower(trim(1.Body)); /\s+(pal|pa|para el|para|el|mañana|hoy|la otra semana|cuando|en la semana)\b.*$/; emptystring)'
preparar = modulo(4, 'util:SetVariables', 1200, 150, variables(
    texto = '{{lower(trim(1.Body))}}',
    partes = '{{split(replace(' + SIN_FECHA + r'; /\s+y\s+/g; ","); ",")}}',
    dia_semana_hoy = '{{formatDate(now; "d"; "America/Mexico_City")}}',
    alias = '{{13.data.alias}}', cantidades = '{{13.data.cantidades}}', precios_centavos = '{{13.data.precios_centavos}}'))
normalizar_m = modulo(8, 'util:SetVariables', 2400, 150, variables(
    telefono = r'{{replace(1.WaId; /^52(1)?(\d{10})$/; "+52$2")}}',
    telefono_valido = r'{{length(replace(1.WaId; /^52(1)?(\d{10})$/; "+52$2")) = 13}}',
    fecha_entrega = '{{formatDate(if(contains(4.texto; "mañana"); addDays(now; 1); if(contains(4.texto; "sábado"); '
                    'addDays(now; if(4.dia_semana_hoy = 6; 7; 6 - 4.dia_semana_hoy)); emptystring)); '
                    '"YYYY-MM-DD"; "America/Mexico_City")}}',
    productos_reconocidos = '{{length(map(7.array; "clave")) = length(7.array)}}',
    total_centavos = '{{sum(map(7.array; "importe_centavos"))}}'))
completo = hoja(10, 'Pedidos', 3000, 0, {'0': '{{1.MessageSid}}', '1': '{{8.telefono}}', '2': '{{8.fecha_entrega}}',
                                         '3': '{{join(map(7.array; "clave"); ", ")}}', '4': '{{8.total_centavos}}'},
                filter = {'name': 'Completo', 'conditions': [[{'a': '{{8.fecha_entrega}}', 'o': 'exist'},
                          {'a': '{{8.telefono_valido}}', 'b': 'true', 'o': 'text:equal'},
                          {'a': '{{8.productos_reconocidos}}', 'b': 'true', 'o': 'text:equal'}]]})
revision = hoja(11, 'Revisión', 3000, 300, {'0': '{{1.MessageSid}}', '1': '{{4.texto}}', '2': 'normalización incompleta'},
                filter = {'name': 'Falta algo', 'conditions': [[{'a': '{{8.fecha_entrega}}', 'o': 'notexist'}],
                          [{'a': '{{8.telefono_valido}}', 'b': 'false', 'o': 'text:equal'}],
                          [{'a': '{{8.productos_reconocidos}}', 'b': 'false', 'o': 'text:equal'}]]})
ES_PEDIDO = [[{'a': '{{1.Body}}', 'b': p, 'o': 'text:contain:ci'}] for p in ('aparta', 'quiero', 'guarda', 'quisiera')]
ruta_pedido = {'flow': [modulo(13, 'datastore:GetRecord', 900, 150, {'key': 'catalogo'}, parameters = {'datastore': 0},
                               filter = {'name': 'Es pedido', 'conditions': ES_PEDIDO}),
                        preparar, *fragmento, normalizar_m,
                        modulo(9, 'builtin:BasicRouter', 2700, 150, routes = [{'flow': [completo]}, {'flow': [revision]}])]}
ruta_otros = {'flow': [hoja(12, 'Revisión', 900, -150, {'0': '{{1.MessageSid}}', '1': '{{1.Body}}', '2': 'rutas de la v2'},
                            filter = {'name': 'No es pedido', 'conditions': [[{'a': '{{1.Body}}', 'b': p, 'o': 'text:notcontain:ci'}
                                                               for p in ('aparta', 'quiero', 'guarda', 'quisiera')]]})]}
v21 = {'name': 'TL Pedidos WhatsApp v2.1',
       'flow': [modulo(1, 'gateway:CustomWebHook', 0, 0, {}, parameters = {'hook': 0, 'maxResults': 1}),
                modulo(2, 'gateway:WebhookRespond', 300, 0, {'status': '200', 'body': '<Response></Response>',
                       'headers': [{'key': 'Content-Type', 'value': 'text/xml'}]}),
                modulo(3, 'builtin:BasicRouter', 600, 0, routes = [ruta_pedido, ruta_otros])],
       'metadata': {'instant': True, 'version': 1,
                    'scenario': {'roundtrips': 1, 'maxErrors': 3, 'autoCommit': True, 'autoCommitTriggerLast': True,
                                 'sequential': True, 'confidential': True, 'dataloss': False, 'dlq': True,
                                 'freshVariables': False},
                    'designer': {'orphans': []}}}

# Validación mínima: ids únicos, posiciones enteras, sin conexiones ni webhooks reales:
def todos(flujo):
    for m in flujo:
        yield m
        for ruta in m.get('routes', []):
            yield from todos(ruta['flow'])
ids = [m['id'] for m in todos(v21['flow'])]
assert len(ids) == len(set(ids)), 'ids repetidos'
assert all(isinstance(v, int) for m in todos(v21['flow']) for v in m['metadata']['designer'].values())
assert all(m['parameters'].get(k, 0) == 0 for m in todos(v21['flow']) for k in ('__IMTCONN__', 'hook', 'datastore'))
ruta = flujos / 'pedidos_whatsapp_v2_1.blueprint.json'
ruta.write_text(json.dumps(v21, ensure_ascii = False, indent = 2), encoding = 'utf-8')

# Créditos por pedido propagando paquetes por la ruta tomada:
def creditos_ruta(flujo, n, rutas_tomadas, p = 1):
    total = 0
    for m in flujo:
        if 'filter' in m and m['filter']['name'] not in rutas_tomadas:
            return total
        if m['module'] == 'builtin:BasicRouter':
            total += sum(creditos_ruta(r['flow'], n, rutas_tomadas, p) for r in m['routes'])
            continue
        total += 1 if m['module'] == 'builtin:BasicAggregator' else p
        p = p * n if m['module'] == 'builtin:BasicFeeder' else (1 if m['module'] == 'builtin:BasicAggregator' else p)
    return total

print('Módulos:', len(ids), '| ids:', sorted(ids), '| escrito:', ruta.as_posix(), f'({ruta.stat().st_size} bytes)')
for k in (1, 3, 12):
    print(f'Pedido completo con {k:>2} renglones: {creditos_ruta(v21["flow"], k, {"Es pedido", "Es renglón", "Completo"})} créditos')
otros = creditos_ruta(v21['flow'], 1, {'No es pedido'})
print('Mensaje que no es pedido:', otros, 'créditos')
mes = mes_b.mean() + (1_560 - PEDIDOS_WHATSAPP_MES) * otros       # 1 560 mensajes de WhatsApp al mes
print(f'Escenario completo al mes: {mes:.0f} créditos ({mes / CUOTA_CORE:.1%} de Core)')

nodos, aristas = nodos_desde_blueprint(v21)
fig, ax = plt.subplots(figsize = (15, 4.6))
dibujar_flujo(nodos, aristas, '', ax = ax)
print(f'{len(nodos)} nodos, {len(aristas)} aristas, profundidad máxima {max(nd["profundidad"] for nd in nodos)}')
fig.suptitle('TL Pedidos WhatsApp v2.1 dibujado desde su blueprint', fontsize = 16)
plt.tight_layout()
plt.show()

# Rescate de pedidos dudosos con Claude Haiku 5.5 y salida estructurada en Python:
import json
import anthropic

client = anthropic.Anthropic()                       # lee ANTHROPIC_API_KEY del entorno
ESQUEMA = {
    'type': 'object',
    'properties': {
        'renglones': {'type': 'array', 'items': {
            'type': 'object',
            'properties': {'clave': {'type': ['string', 'null']}, 'cantidad': {'type': 'integer'}},
            'required': ['clave', 'cantidad'], 'additionalProperties': False}},
        'fecha_entrega': {'type': ['string', 'null'], 'description': 'AAAA-MM-DD o null si no se puede saber'},
        'pregunta_al_cliente': {'type': ['string', 'null']},
    },
    'required': ['renglones', 'fecha_entrega', 'pregunta_al_cliente'],
    'additionalProperties': False,
}
SISTEMA = ('Normaliza encargos de una panadería. Usa solo las claves del catálogo. '
           'Si la fecha no se puede saber con certeza, devuelve null y redacta una pregunta breve, en usted. '
           'No adivines: un null con pregunta vale más que una fecha inventada.')

def rescatar(texto, recibido_local, catalogo):
    # Solo viaja el texto del pedido: sin teléfono ni nombre (seudonimización del Día 6):
    respuesta = client.messages.create(
        model = 'claude-haiku-5-5',
        max_tokens = 400,
        system = SISTEMA,
        messages = [{'role': 'user', 'content': f'Catálogo: {json.dumps(catalogo, ensure_ascii = False)}\n'
                                                f'Recibido (America/Mexico_City): {recibido_local}\n'
                                                f'Mensaje: {texto}'}],
        output_config = {'effort': 'low', 'format': {'type': 'json_schema', 'schema': ESQUEMA}},
    )
    if respuesta.stop_reason != 'end_turn':
        return None, respuesta.stop_reason                # refusal o max_tokens: a revisión humana
    texto_json = next(b.text for b in respuesta.content if b.type == 'text')
    return json.loads(texto_json), respuesta.usage

catalogo = {'hogaza': 'P01', 'croissant': 'P05', 'pay de queso': 'P12', 'rol de canela': 'P06'}
for mensaje in ['me guarda 3 crosant y 1 pay de keso pal sábado',
                'quiero 2 hogazas para el cumple de mi mamá']:
    datos, uso = rescatar(mensaje, '2026-02-20 23:30', catalogo)
    print(datos)
    print('Tokens:', uso.input_tokens, 'de entrada y', uso.output_tokens, 'de salida')

# Salida de ejemplo (puede variar):
# {'renglones': [{'clave': 'P05', 'cantidad': 3}, {'clave': 'P12', 'cantidad': 1}], 'fecha_entrega': '2026-02-21', 'pregunta_al_cliente': None}
# Tokens: 431 de entrada y 74 de salida
# {'renglones': [{'clave': 'P01', 'cantidad': 2}], 'fecha_entrega': None, 'pregunta_al_cliente': '¿Para qué día es el cumpleaños? Así le tenemos listas sus hogazas.'}
# Tokens: 428 de entrada y 69 de salida