Upload 3 files

extraer_movimientos.py

@@ -650,6 +650,376 @@ def _amex(pdf, mes_anio):
     return movs
 
 
+# ---- MONEX -----------------------------------------------------------------
+# La tabla de MONEX tiene OCHO columnas y CUATRO de ellas son numericas y
+# CONTIGUAS: 'Movimiento garantia'(x1~533), 'Saldo en garantia'(x1~609),
+# 'Saldo disponible'(x1~688) y 'Saldo total'(x1~764). Por eso las bandas se leen
+# del ENCABEZADO de CADA pagina y no se fijan a mano: la subcuenta en dolares que
+# MONEX imprime al final del mismo estado usa OTRAS coordenadas (Abonos x1~380 en
+# vez de ~367, Cargos ~452 en vez de ~447) y encima parte el encabezado en DOS
+# renglones.
+_MX_FECHA = re.compile(r'^(\d{1,2})/([A-Za-z]{3})$')
+# Holgura de banda. Los importes van alineados a la DERECHA exactamente al x1 del
+# encabezado (medido en MARZO+ABRIL: las 722 celdas de dinero de las columnas
+# Abonos/Cargos/'Saldo total' dan x1_monto - x1_encabezado = 0.0 pt EXACTO), y la
+# columna numerica vecina mas cercana esta a 76 pt.
+_MX_TOL = 8.0
+# Hueco vertical minimo que SEPARA dos bloques de movimiento. Medido en
+# MARZO+ABRIL: dentro del bloque 2.0-9.8 pt, entre bloques 16.8-19.4 pt.
+_MX_SEP = 13.0
+_MX_PERIODO = re.compile(
+    r'PERIODO\s*:?\s*Del\s+(\d{1,2})\s+([A-Za-zÁÉÍÓÚáéíóú]+)\s+(\d{4})\s+al\s+'
+    r'(\d{1,2})\s+([A-Za-zÁÉÍÓÚáéíóú]+)\s+(\d{4})', re.I)
+# Ruido de plomeria del bloque: identifica la operacion ante el banco pero no
+# describe el movimiento ni aporta el NOMBRE de la contraparte. Se quita SOLO la
+# etiqueta con su valor numerico, nunca texto con nombres.
+_MX_RUIDO = [
+    re.compile(r'Clave\s+de\s+Rastreo\s*:?\s*[\w/]*', re.I),
+    re.compile(r'Referencia\s+Numerica\s*:?\s*\d*', re.I),
+    re.compile(r'Cuenta\s+(?:beneficiaria|ordenante)\s*:?\s*\d*', re.I),
+    re.compile(r'Fecha\s+Confirmaci\w*\s*n?\s*de\s+[Ll]iquidaci\w*\s*n?\s*:?\s*'
+               r'[\d\-]*\s*[\d:]*', re.I),
+    re.compile(r'Dato\s+no\s+verificado\s+por\s+esta\s+institu\S*', re.I),
+    re.compile(r'Email:\S+', re.I),
+    re.compile(r'\b\d{15,}\b'),
+]
+
+
+def _monex_periodo(pdf):
+    """mes->anio del PERIODO de la hoja 1 ('PERIODO: Del 1 Marzo 2026 al 31 marzo
+    2026'): meses en ESPANOL y con mayuscula inconsistente, y sin anio en la fecha
+    de cada movimiento ('02/Mar'). Los meses FUERA del periodo se fechan hacia
+    ATRAS desde su inicio (igual que en BBVA), para que una operacion rezagada de
+    diciembre dentro del estado de enero no se vaya al anio SIGUIENTE."""
+    t = ' '.join((p.extract_text() or '') for p in pdf.pages[:3])
+    a = {}
+    y1 = None
+    m = _MX_PERIODO.search(t)
+    if m:
+        m1, y1 = _MESES_ES.get(_up(m.group(2))), int(m.group(3))
+        m2, y2 = _MESES_ES.get(_up(m.group(5))), int(m.group(6))
+        if m2:
+            a[m2] = y2
+        if m1:
+            a[m1] = y1
+            y, mth = y1, m1
+            for _ in range(11):
+                mth -= 1
+                if mth == 0:
+                    mth, y = 12, y - 1
+                a.setdefault(mth, y)
+    else:
+        # respaldo: 'Peso Mexicano al 31 Marzo 2026' del resumen de la hoja 2
+        m2 = re.search(r'\bal\s+\d{1,2}\s+([A-Za-zÁÉÍÓÚáéíóú]+)\s+(\d{4})', t, re.I)
+        if m2 and _MESES_ES.get(_up(m2.group(1))):
+            y1 = int(m2.group(2))
+            a[_MESES_ES[_up(m2.group(1))]] = y1
+    ys = re.findall(r'\b(20\d{2})\b', t)
+    return a, (y1 or (int(ys[0]) if ys else 2025))
+
+
+def _monex_hdr(words):
+    """Encabezado de la tabla de movimientos -> (bandas, zonas, top_fin), o None
+    si la pagina no es de la tabla.
+
+    Se exige la firma COMPLETA (Descripcion + Referencia + Abonos + Cargos +
+    'Saldo total'): la hoja del 'Resumen Divisas' tambien trae las palabras
+    'Abonos', 'Cargos' y 'Saldo total:', y con una puerta laxa se colaria.
+
+    Como se distingue 'Saldo total'(x1~764) de las otras tres columnas numericas
+    contiguas: por su ETIQUETA COMPLETA, no por su posicion. La etiqueta se
+    reconstruye a partir del par de palabras SALDO + TOTAL, aceptando las dos
+    formas en que MONEX la imprime -- CONTIGUAS en el mismo renglon
+    ('Saldo'@723/745 + 'total'@747/764, hueco 1.9 pt) o APILADAS en dos renglones
+    con las cajas solapadas en x ('Saldo'@742/763 arriba, 'total'@746/763 abajo,
+    en la tabla en dolares). Al exigir que la 2a palabra sea literalmente 'total',
+    'Saldo disponible'(688), 'Saldo en garantia'(609) y 'Movimiento
+    garantia'(533) quedan descartadas aunque esten pegadas."""
+    anc = [w for w in words
+           if _up(w['text']).rstrip(':') == 'DESCRIPCION' and w['x0'] < 220]
+    if not anc:
+        return None
+    desc = anc[0]
+    hdr = [w for w in words if abs(w['top'] - desc['top']) <= 18]
+
+    def uno(nombre):
+        c = [w for w in hdr if _up(w['text']) == nombre]
+        return c[0] if c else None
+
+    ref, ab, ca = uno('REFERENCIA'), uno('ABONOS'), uno('CARGOS')
+    if not (ref and ab and ca):
+        return None
+    sal = None
+    for t in [w for w in hdr if _up(w['text']) == 'TOTAL']:
+        for s in [w for w in hdr if _up(w['text']) == 'SALDO']:
+            contiguo = abs(s['top'] - t['top']) <= 2 and 0 <= (t['x0'] - s['x1']) <= 3.5
+            apilado = (abs(s['top'] - t['top']) > 2
+                       and min(s['x1'], t['x1']) > max(s['x0'], t['x0']))
+            if contiguo or apilado:
+                x1 = max(s['x1'], t['x1'])
+                sal = x1 if sal is None else max(sal, x1)
+    if sal is None:
+        return None
+    bandas = {'dep': ab['x1'], 'ret': ca['x1'], 'sal': sal}
+    # zonas en x: DESCRIPCION va del inicio de su encabezado al de 'Referencia';
+    # la FECHA vive a la izquierda de la descripcion ('Fechas Liquidacion
+    # (Pactada)', x0~30).
+    zonas = {'d0': desc['x0'] - 4, 'd1': ref['x0'] - 2, 'f1': desc['x0'] - 6}
+    return bandas, zonas, max(w['top'] for w in hdr) + 3
+
+
+def _monex(pdf):
+    """MONEX: layout multilinea con la fila del IMPORTE en MEDIO del bloque de
+    descripcion (hay lineas de descripcion ANTES y DESPUES), la fecha EN LA MISMA
+    fila que los importes, y bloques que CRUZAN de pagina.
+
+    Tres trampas propias de MONEX:
+     1) Abonos Y Cargos se imprimen LOS DOS en cada fila (uno en '0.00'), asi que
+        la regla de los otros bancos ('trae deposito Y retiro a la vez -> es fila
+        de totales, ignorar') borraria TODOS los movimientos. Aqui un movimiento
+        real es abonos>0 XOR cargos>0. Las filas 0.00/0.00 (deposito de intereses
+        que el ISR netea el mismo dia) no mueven el saldo y no son movimiento.
+     2) El estado trae al final una SUBCUENTA EN DOLARES con la MISMA tabla y
+        otras coordenadas. Se corta la lectura al cerrar la cuenta en pesos.
+     3) La fecha viene 'DD/Mmm' SIN anio (ver _monex_periodo).
+    """
+    mes_anio, anio_def = _monex_periodo(pdf)
+    filas = []                        # (ipag, top, row, bandas, zonas)
+    for ip, page in enumerate(pdf.pages):
+        words = page.extract_words(use_text_flow=False, keep_blank_chars=False)
+        if not words:
+            continue
+        T = _up(' '.join(w['text'] for w in words))
+        # La cuenta en PESOS es la PRIMERA del estado. Un segundo bloque 'Resumen
+        # cuenta' o un titulo 'Movimientos de <mes> EN <divisa>' despues de haber
+        # empezado a leer movimientos = SUBCUENTA EN OTRA DIVISA (MONEX cierra el
+        # estado con 'dolar americano': misma tabla, importes en USD, y su propia
+        # cadena de saldos que arranca otra vez desde su saldo inicial). Sumarla
+        # contaminaria los totales en pesos.
+        if filas and (re.search(r'RESUMEN\s+CUENTA', T)
+                      or re.search(r'MOVIMIENTOS\s+DE\s+\w+\s+EN\s+\S', T)):
+            break
+        h = _monex_hdr(words)
+        if not h:
+            continue
+        bandas, zonas, hdr_fin = h
+        pw = {}
+        for w in words:
+            if w['top'] > hdr_fin:
+                pw.setdefault(round(w['top'], 1), []).append(w)
+        fin_tabla = False
+        for top in sorted(pw):
+            row = sorted(pw[top], key=lambda x: x['x0'])
+            # Etiquetas de la propia tabla, impresas en la ZONA DE COLUMNAS
+            # NUMERICAS (a la derecha de la descripcion): no son movimiento ni
+            # descripcion. 'Saldo final:' CIERRA la tabla de la cuenta en pesos.
+            etiq = _up(' '.join(w['text'] for w in row
+                                if w['x0'] >= zonas['d1'] and not MONEY.match(w['text'])))
+            if etiq.startswith(('SALDO FINAL', 'TOTAL')):
+                fin_tabla = True
+                break
+            if etiq.startswith('SALDO INICIAL') or etiq.startswith('HOJA'):
+                continue      # fila de apertura y pie de pagina 'Hoja N de M'
+            filas.append((ip, top, row, bandas, zonas))
+        if fin_tabla:
+            break
+
+    # 1) filas de IMPORTE: fecha 'DD/Mmm' en la columna de fechas + monto en la
+    #    banda Abonos o Cargos. Se guarda tambien el 'Saldo total' de la fila.
+    imp = {}
+    for i, (_ip, _top, row, bandas, zonas) in enumerate(filas):
+        fk = None
+        for w in row:
+            if w['x0'] < zonas['f1']:
+                fk = fk or _MX_FECHA.match(w['text'])
+        if not fk or _up(fk.group(2)) not in _MESES:
+            continue
+        d = r = s = None
+        for w in row:
+            if not MONEY.match(w['text']):
+                continue
+            v = _num(w['text'])
+            if abs(w['x1'] - bandas['dep']) <= _MX_TOL: d = v
+            elif abs(w['x1'] - bandas['ret']) <= _MX_TOL: r = v
+            elif abs(w['x1'] - bandas['sal']) <= _MX_TOL: s = v
+        if d is None and r is None:
+            continue
+        imp[i] = (fk, d or 0.0, r or 0.0, s)
+
+    # 2) reparto de las lineas de DESCRIPCION entre filas de importe consecutivas.
+    #    El corte va en el HUECO VERTICAL MAS GRANDE que hay entre las dos: dentro
+    #    de un bloque el interlineado es 9.8 pt (y 2-7 pt alrededor de la fila del
+    #    importe, que MONEX centra en el bloque) y entre bloques 16.8-19.4 pt
+    #    (medido en los 160 pares de filas de importe que caen en la misma hoja de
+    #    MARZO+ABRIL: intra-bloque max 9.8, separador min 16.8).
+    #    El bloque CRUZA de pagina (medido: el bloque de MARZO hoja 3 top=554
+    #    sigue con 10 renglones al inicio de la hoja 4), asi que un salto de
+    #    pagina NO es corte por si mismo. Pero cuando el bloque siguiente ARRANCA
+    #    justo en la primera fila de la hoja no hay hueco separador que encontrar:
+    #    si el mayor hueco de las dos hojas se queda por debajo de _MX_SEP, el
+    #    corte ES el salto de pagina (sin esto, el ultimo movimiento de la hoja se
+    #    quedaba con la primera linea del bloque siguiente).
+    idx = sorted(imp)
+    corte = {}
+    for a, b in zip(idx, idx[1:]):
+        mejor = (-1.0, None)
+        salto = None
+        for j in range(a, b):
+            if filas[j][0] != filas[j + 1][0]:
+                salto = j                    # ultima fila antes de cambiar de hoja
+                continue
+            hueco = filas[j + 1][1] - filas[j][1]
+            if hueco > mejor[0]:
+                mejor = (hueco, j)
+        if mejor[0] >= _MX_SEP or salto is None:
+            corte[a] = mejor[1] if mejor[1] is not None else a
+        else:
+            corte[a] = salto
+
+    movs = []
+    for k, i in enumerate(idx):
+        ini = corte[idx[k - 1]] + 1 if k else 0
+        fin = corte[i] if k + 1 < len(idx) else len(filas) - 1
+        fk, d, r, s = imp[i]
+        if (d > 0) == (r > 0):
+            continue    # 0.00/0.00 (intereses neteados por el ISR el mismo dia)
+        # La descripcion sale de la COLUMNA DE DESCRIPCION (x0 entre el inicio de
+        # su encabezado y el de 'Referencia', ~104-240). No hace falta filtrar
+        # tokens con formato de dinero: la columna numerica mas a la izquierda
+        # (Abonos) arranca en x0>=325, asi que nada de ahi cae en la banda, y en
+        # cambio si aparecen importes que SON parte del texto ('Compra de divisas
+        # 5.80 USD a un tipo de cambio de 18.1235').
+        desc = []
+        for j in range(ini, fin + 1):
+            z = filas[j][4]
+            for w in filas[j][2]:
+                if z['d0'] <= w['x0'] < z['d1']:
+                    desc.append(w['text'])
+        txt = re.sub(r'\s{2,}', ' ', ' '.join(desc))
+        for rx in _MX_RUIDO:
+            txt = rx.sub(' ', txt)
+        txt = re.sub(r'\s{2,}', ' ', txt).strip(' ,;:')
+        mnum = _MESES[_up(fk.group(2))]
+        movs.append({
+            'fecha': '%02d-%s-%d' % (int(fk.group(1)), _up(fk.group(2)),
+                                     mes_anio.get(mnum, anio_def)),
+            'concepto': txt[:220],
+            'deposito': d if d > 0 else None,
+            'retiro': r if r > 0 else None,
+            'saldo': s,
+        })
+    return movs
+
+
+# ---- HSBC -------------------------------------------------------------------
+# HSBC imprime DOS veces los mismos importes: en 'DETALLE MOVIMIENTOS CUENTA DE
+# CHEQUES' (la contabilidad real) y otra vez en las tablas informativas
+# "Informacion SPEI's Enviados/Recibidos durante el periodo", que repiten cada
+# transferencia con su 'Monto del pago'. Leer las dos DUPLICA los importes: es
+# exactamente lo que hacia Gemini. Aqui se extrae SOLO el DETALLE, cortando la
+# seccion en cuanto aparece cualquier otro bloque.
+_HSBC_PERIODO = re.compile(
+    r'Per[ií]odo\s*del\s*(\d{2})/(\d{2})/(\d{4})\s*al\s*(\d{2})/(\d{2})/(\d{4})', re.I)
+# Encabezado de la tabla de movimientos. Coordenadas medidas identicas en los 6
+# estados: Retiro/Cargo x1=397.0, Deposito/Abono x1=481.4, Saldo x1=549.1. Las
+# etiquetas van CENTRADAS sobre su columna y los importes ALINEADOS A LA DERECHA,
+# asi que el offset etiqueta->importe no es constante (+4 en cargo, -9 en abono,
+# +16 en saldo): de ahi la tolerancia amplia. Las columnas estan a 68-84 pt entre
+# si, asi que +-22 no puede solaparlas.
+_HSBC_TOL = 22.0
+# Todo lo que CIERRA la seccion de movimientos.
+# Encabezados de OTRAS secciones. Se ancla al INICIO de la fila y solo se evalua
+# en filas que NO son movimiento: la palabra 'SPEI' aparece dentro de la
+# descripcion de muchos movimientos legitimos ('CGO SPEI NOMINA 15FEB26'), asi
+# que buscarla en cualquier parte cortaba la tabla en el primer movimiento SPEI.
+_HSBC_FIN = re.compile(
+    r'^(Informaci[oó]n|Emitido\s+por|RESUMEN|CIFRAS\s+EXPRESADAS|Estimado|'
+    r'Otros\s+Datos|Tus\s+Movimientos|Comisiones\s+Cobradas)', re.I)
+
+
+def _hsbc_periodo(pdf):
+    """(mes, anio) del periodo del estado. El detalle solo trae el DIA."""
+    t = ''
+    for pg in pdf.pages[:2]:
+        t += (pg.extract_text() or '')
+    m = _HSBC_PERIODO.search(t)
+    if m:
+        return int(m.group(2)), int(m.group(3))
+    return None, None
+
+
+def _hsbc_hdr(filas, tops):
+    """(top, bandas) del encabezado del DETALLE en esta pagina, o None."""
+    for top in tops:
+        tx = {w['text']: w for w in filas[top]}
+        if 'Retiro/Cargo' in tx and 'Depósito/Abono' in tx:
+            sal = None
+            for w in filas[top]:
+                if w['text'] == 'Saldo' and w['x1'] > 500:
+                    sal = w['x1']
+            b = {'ret': tx['Retiro/Cargo']['x1'], 'dep': tx['Depósito/Abono']['x1']}
+            if sal is not None:
+                b['sal'] = sal
+            return top, b
+    return None
+
+
+def _hsbc(pdf):
+    """HSBC: una fila = un movimiento. La columna 'Dia' trae SOLO el dia (el mes
+    y el anio salen del periodo). Columnas Retiro/Cargo, Deposito/Abono y Saldo
+    alineadas a la derecha. Las lineas siguientes sin dia son continuacion de la
+    descripcion o de la referencia."""
+    mes, anio = _hsbc_periodo(pdf)
+    movs = []
+    for page in pdf.pages:
+        words = page.extract_words(use_text_flow=False, keep_blank_chars=False)
+        filas = {}
+        for w in words:
+            filas.setdefault(round(w['top']), []).append(w)
+        tops = sorted(filas)
+        h = _hsbc_hdr(filas, tops)
+        if not h:
+            continue
+        hdr_top, banda = h
+
+        def col(x1):
+            for nom in ('ret', 'dep', 'sal'):
+                if nom in banda and abs(x1 - banda[nom]) <= _HSBC_TOL:
+                    return nom
+            return None
+
+        for top in tops:
+            if top <= hdr_top + 2:
+                continue
+            row = sorted(filas[top], key=lambda z: z['x0'])
+            txt = ' '.join(w['text'] for w in row)
+            ret = dep = sal = None
+            for w in row:
+                if MONEY.match(w['text']):
+                    c = col(w['x1'])
+                    if c == 'ret': ret = _num(w['text'])
+                    elif c == 'dep': dep = _num(w['text'])
+                    elif c == 'sal': sal = _num(w['text'])
+            # descripcion: entre la columna del dia y la de Referencia/Serial
+            desc = ' '.join(w['text'] for w in row
+                            if 60 < w['x0'] < 310 and not MONEY.match(w['text']))
+            # dia: primer token, 1-2 digitos, en la columna de la izquierda
+            md = re.fullmatch(r'(\d{1,2})', row[0]['text'])
+            es_mov = bool(md) and row[0]['x1'] <= 60 and (ret is not None or dep is not None)
+            if es_mov:
+                fecha = ('%02d-%s-%d' % (int(md.group(1)), _MES_ABBR[mes], anio)
+                         if mes else '')
+                movs.append({'fecha': fecha, 'concepto': desc.strip(),
+                             'deposito': dep, 'retiro': ret, 'saldo': sal})
+            elif _HSBC_FIN.match(txt.strip()):
+                break                      # arranca otra seccion: se cierra el DETALLE
+            elif movs and desc.strip():
+                movs[-1]['concepto'] = (movs[-1]['concepto'] + ' ' + desc.strip()).strip()
+    for m in movs:
+        m['concepto'] = m['concepto'][:220]
+    return movs
+
+
 def extraer(path):
     import pdfplumber
     rep = tb.extraer(path)
@@ -690,6 +1060,10 @@ def extraer(path):
             movs = _bbva(pdf)
         elif banco == 'BANORTE':
             movs = _banorte(pdf)
+        elif banco == 'MONEX':
+            movs = _monex(pdf)
+        elif banco == 'HSBC':
+            movs = _hsbc(pdf)
         elif bandas:
             movs = _por_bandas(pdf, bandas)     # Santander (bandas fijas)
         else:
@@ -699,6 +1073,37 @@ def extraer(path):
     rd, rr = rep['depositos'], rep['retiros']
     cuadra = (rd is not None and rr is not None
               and abs(suma_dep - rd) <= 1.0 and abs(suma_ret - rr) <= 1.0)
+
+    # CUADRE POR CADENA DE SALDOS (respaldo). Algunos bancos NETEAN en sus totales
+    # de cabecera un par de movimientos que si movieron el saldo. Caso medido:
+    # HSBC FEBRERO trae la comision de administracion (599.00 + IVA 95.84) y la
+    # BONIFICACION de la del mes anterior (599.00 + 95.84); HSBC las cancela entre
+    # si y no las cuenta ni en 'Depositos/Abonos' ni en 'Retiros/Cargos', asi que
+    # nuestra suma queda +694.84 de CADA lado. Los 34 movimientos son reales: la
+    # cadena de saldos impresa los confirma uno por uno.
+    #
+    # Solo se acepta con las TRES condiciones a la vez, que juntas son mas fuertes
+    # que el cuadre de sumas: (1) el banco imprime saldo en >=90% de los
+    # movimientos y TODOS coinciden con el acumulado, (2) el saldo final calculado
+    # cae exacto en el que reporta el banco, y (3) la diferencia es la MISMA en
+    # depositos y en retiros (neteo, no dinero perdido ni inventado). Un movimiento
+    # duplicado rompe la cadena y uno faltante rompe el saldo final, asi que esto
+    # no puede enmascarar los defectos que la compuerta existe para atrapar.
+    cuadra_saldo = False
+    si0, sf0 = rep.get('saldo_inicial'), rep.get('saldo_final')
+    if (not cuadra and rd is not None and rr is not None
+            and si0 is not None and sf0 is not None and movs):
+        con_saldo = [m for m in movs if m.get('saldo') is not None]
+        if len(con_saldo) >= 0.9 * len(movs):
+            acc, mal = si0, 0
+            for m in movs:
+                acc = round(acc + (m['deposito'] or 0) - (m['retiro'] or 0), 2)
+                if m.get('saldo') is not None and abs(acc - m['saldo']) > 0.01:
+                    mal += 1
+            simetrico = abs((suma_dep - rd) - (suma_ret - rr)) <= 0.01
+            if mal == 0 and abs(acc - sf0) <= 0.01 and simetrico:
+                cuadra_saldo = True
+    cuadra = cuadra or cuadra_saldo
     # transacciones en el FORMATO que consume el flujo (igual que Gemini):
     # fecha YYYY-MM-DD, descripcion, cargos(retiro), abonos(deposito), saldo, moneda
     tx_flujo = []
@@ -715,6 +1120,7 @@ def extraer(path):
         'banco': banco, 'moneda': moneda, 'ok': bool(cuadra), 'cuadra': bool(cuadra),
         'suma_dep': suma_dep, 'suma_ret': suma_ret, 'rep_dep': rd, 'rep_ret': rr,
         'saldo_inicial': rep.get('saldo_inicial'), 'saldo_final': rep.get('saldo_final'),
+        'cuadra_por_saldo': bool(cuadra_saldo),
         'n': len(movs), 'transacciones': tx_flujo,
     }
 

fill_template.py

@@ -20,9 +20,15 @@ MESES_ES = ['ene', 'feb', 'mar', 'abr', 'may', 'jun',
 
 # Comisiones por SPEI / transferencia. NO se descartan: solo se MARCAN (bandera
 # en la columna N de 08_EC_Raw) para la comparativa de # de movimientos.
+# OJO: 'CGO' y 'CARGO' NO son marcas de comision, son la palabra que muchos bancos
+# usan para el movimiento mismo. Con ellas dentro, HSBC marcaba 107 de 208
+# movimientos como 'comision por SPEI' (son transferencias reales: 'CGO SPEI FACT
+# 2440' de $174,000, 'CGO SPEI FACT DTEFACT1466' de $1,832,928) y SANTANDER 12 mas
+# ('CARGO TRANSFERENCIA ENLACE' de $150,000). Una comision real dice COMISION/COM/
+# CUOTA de forma explicita. La bandera es informativa (columna N), no mueve dinero.
 COMISION_RE = re.compile(
-    r'(COMIS\w*|\bCOM\b\.?|\bCGO\b\.?|CARGO|CUOTA)[\s\S]{0,50}(SPEI|TRANSFER\w*|\bTRANSF\b|\bTEF\b)'
-    r'|(SPEI|TRANSFER\w*|\bTRANSF\b|\bTEF\b)[\s\S]{0,50}(COMIS\w*|\bCOM\b\.?)',
+    r'(COMIS\w*|\bCOM\b\.?|CUOTA)[\s\S]{0,50}(SPEI|TRANSFER\w*|\bTRANSF\b|\bTEF\b)'
+    r'|(SPEI|TRANSFER\w*|\bTRANSF\b|\bTEF\b)[\s\S]{0,50}(COMIS\w*|\bCOM\b\.?|CUOTA)',
     re.IGNORECASE)
 
 # Filas de saldos en 03_EstadosCuenta (V3.8.3: se insertaron 4 renglones en la
@@ -1220,4 +1226,3 @@ def main():
 
 if __name__ == '__main__':
     main()
-    

totales_banco.py

@@ -29,6 +29,52 @@ M = _PRE + r'([\d,]+\.\d{2})'
 _NUM = r'[\d,]+\.\d{2}'
 
 
+# ---------------------------------------------------------------------------
+# HSBC: fuente con nombres de glifo '/EX<ddd>000' donde <ddd> es el codigo
+# UNICODE DECIMAL del caracter ('EX067000' -> 'C'). Es la salida de Xenos
+# D2eVision, la herramienta de mainframe con la que HSBC genera el estado.
+# Sin traducir esto, pypdf devuelve literalmente '/EX067000/EX085000...' y
+# pdfplumber devuelve mojibake ('...(cid:228)...'): CERO importes reconocibles,
+# el banco sale DESCONOCIDO y todo el estado cae a Gemini.
+_GLIFO_EX = re.compile(r'/EX(\d{3})000')
+
+
+def decodificar_glifos(t):
+    """Traduce los nombres de glifo '/EX<ddd>000' a su caracter real."""
+    if '/EX' not in t:
+        return t
+    return _GLIFO_EX.sub(lambda m: chr(int(m.group(1))), t)
+
+
+def _parchar_pdfminer():
+    """Ensena a pdfminer (y por tanto a pdfplumber) a resolver los glifos
+    'EX<ddd>000' de HSBC, para que extract_words devuelva texto real CON
+    coordenadas. Solo intercepta nombres que ningun otro banco usa, asi que no
+    puede afectar la extraccion de los demas. Idempotente."""
+    try:
+        import pdfminer.encodingdb as _edb
+        import pdfminer.pdffont as _pf
+    except ImportError:
+        return
+    if getattr(_edb, '_ec_parche_hsbc', False):
+        return
+    _orig = _edb.name2unicode
+
+    def _n2u(name):
+        m = re.fullmatch(r'EX(\d{3})000', name or '')
+        if m:
+            return chr(int(m.group(1)))
+        return _orig(name)
+
+    _edb.name2unicode = _n2u
+    if hasattr(_pf, 'name2unicode'):      # pdffont importa el nombre directo
+        _pf.name2unicode = _n2u
+    _edb._ec_parche_hsbc = True
+
+
+_parchar_pdfminer()
+
+
 def money(s):
     return float(s.replace(',', '').replace('$', '').replace(' ', ''))
 
@@ -64,7 +110,7 @@ def leer_texto(path, nprim=3, nult=2, todo=False):
         n = len(r.pages)
         idx = range(n) if todo else sorted(
             set(range(min(nprim, n))) | set(range(max(0, n - nult), n)))
-        return '\n'.join((r.pages[i].extract_text() or '') for i in idx)
+        return decodificar_glifos('\n'.join((r.pages[i].extract_text() or '') for i in idx))
     except Exception:
         import pdfplumber
         with pdfplumber.open(path) as pdf:
@@ -72,7 +118,7 @@ def leer_texto(path, nprim=3, nult=2, todo=False):
             n = len(ps)
             idx = range(n) if todo else sorted(
                 set(range(min(nprim, n))) | set(range(max(0, n - nult), n)))
-            return '\n'.join((ps[i].extract_text() or '') for i in idx)
+            return decodificar_glifos('\n'.join((ps[i].extract_text() or '') for i in idx))
 
 
 # El RFC del banco EMISOR es unico y NO se confunde con nombres que aparecen en
@@ -82,6 +128,8 @@ RFC_BANCO = {
     'BSM970519DU8': 'SANTANDER',   # Banco Santander Mexico
     'BNM840515VB1': 'BANAMEX',     # Banco Nacional de Mexico (Citibanamex)
     'BMN930209927': 'BANORTE',     # Banco Mercantil del Norte
+    'BMI9704113PA': 'MONEX',       # Banco Monex, S.A. (Monex Grupo Financiero)
+    'HMI950125KG8': 'HSBC',        # HSBC Mexico, S.A. (lo imprime 'HMI-950125KG8')
     'AEC810901298': 'AMEX',        # American Express Company (Mexico) - TARJETA de credito
 }
 
@@ -142,7 +190,8 @@ def detectar_banco(t):
     #    emisor sale en el encabezado/pie de CADA pagina, mientras que el de una
     #    contraparte sale 1-2 veces. (Antes se tomaba el primero del dict -> un PDF de
     #    Banorte que mencionaba el RFC de Santander se detectaba mal como Santander.)
-    U = re.sub(r'\s+', '', t.upper())
+    # Se quitan tambien los GUIONES: HSBC imprime su RFC como 'HMI-950125KG8'.
+    U = re.sub(r'[\s\-]+', '', t.upper())
     counts = {}
     for rfc, banco in RFC_BANCO.items():
         c = U.count(rfc)
@@ -232,6 +281,17 @@ def extraer(path, _todo=False):
     # completo: un banco nuevo cuyo resumen viva a media docena de paginas sigue
     # funcionando, solo que pagando el costo de leerlo entero.
     t = leer_texto(path, todo=_todo)
+    # PDF SIN CAPA DE TEXTO: cada letra viene como trazo vectorial (0 caracteres,
+    # 0 fuentes). Pasa con estados RE-IMPRESOS a PDF en vez de descargados del
+    # portal del banco. Sin texto no hay nada que extraer por regex NI por IA de
+    # texto: el unico camino seria OCR. Se corta aqui para no pagar el reintento con
+    # el documento completo (devuelve la misma cadena vacia), y la bandera permite
+    # apartar el PDF en vez de mandarlo a Gemini, que sin texto solo puede inventar.
+    if not t.strip():
+        return {'banco': 'DESCONOCIDO', 'moneda': 'MXN',
+                'depositos': None, 'retiros': None, 'saldo_inicial': None,
+                'saldo_final': None, 'cuadre_interno': None, 'ok': False,
+                'sin_capa_texto': True}
     banco = detectar_banco(t)
     moneda = detectar_moneda(t)
 
@@ -256,6 +316,7 @@ def extraer(path, _todo=False):
         return r
 
     dep = ret = si = sf = None
+    saldo_promedio = None   # solo MONEX lo publica en su resumen
 
     if banco == 'SANTANDER':
         # PRIMARIO: la linea 'Saldo inicial +Depositos - Retiros = Saldo final'
@@ -285,6 +346,42 @@ def extraer(path, _todo=False):
         si = find(r'Saldo Anterior\s*' + M, t) or find(r'Saldo Inicial\s*' + M, t)
         sf = find(r'Saldo Final\s*' + M, t)
 
+    elif banco == 'HSBC':
+        # Resumen de la pagina 1 ('RESUMEN DE CUENTAS'). Las etiquetas vienen
+        # PARTIDAS en varias lineas por el ancho de la caja, y el '4' que las
+        # precede es un bullet del catalogo de fuentes de HSBC, no un numero:
+        #   '4Saldo Inicial del\nPeriodo\n$ 11,902.36'
+        #   '4Depositos/\nAbonos\n$ 226,671.87'
+        #   '4Retiros/Cargos$ 185,611.64'
+        # Por eso se tolera cualquier cosa entre la etiqueta y el importe con
+        # [\s\S]{0,40} en vez de exigirlos en el mismo renglon.
+        dep = find(r'Dep[oó]sitos\s*/[\s\S]{0,20}Abonos[\s\S]{0,12}?' + M, t)
+        ret = find(r'Retiros\s*/\s*Cargos[\s\S]{0,12}?' + M, t)
+        si = find(r'Saldo\s*Inicial\s*del[\s\S]{0,20}Periodo[\s\S]{0,12}?' + M, t)
+        sf = find(r'Saldo\s*Final\s*del[\s\S]{0,20}Periodo[\s\S]{0,12}?' + M, t)
+        saldo_promedio = find(r'Saldo\s*Promedio\s*en\s*el\s*Mes[^$\n]{0,70}?' + M, t)
+
+    elif banco == 'MONEX':
+        # El resumen vive en la pagina 2 ('Resumen Cuenta', columna derecha). DOS
+        # trampas, ambas resueltas exigiendo los DOS PUNTOS de la etiqueta:
+        #  1) en la MISMA pagina hay una tabla 'Resumen Divisas' con encabezados
+        #     'Divisa | Saldo inicial del periodo | Abonos | Cargos | Saldo' y la fila
+        #     'dolar americano 1.06 38,779.50 38,779.60 0.96': son los totales de la
+        #     SUBCUENTA EN DOLARES, no los de la cuenta en pesos.
+        #  2) el encabezado de la tabla de movimientos repite 'Saldo total' y
+        #     'Saldo disponible' SIN dos puntos.
+        # Las etiquetas del resumen son las unicas que llevan ':'.
+        dep = find(r'Total\s*abonos\s*:' + M, t)
+        ret = find(r'Total\s*cargos\s*:' + M, t)
+        si = find(r'Saldo\s*inicial\s*:' + M, t)
+        sf = find(r'Saldo\s*total\s*:' + M, t) or find(r'Saldo\s*vista\s*:' + M, t)
+        saldo_promedio = find(r'Saldo\s*promedio\s*\(\s*Intereses\s*\)\s*:' + M, t)
+        # Si el cliente tiene subcuenta en dolares, el PDF trae MAS ADELANTE un
+        # SEGUNDO bloque 'Resumen cuenta / dolar americano' con las MISMAS etiquetas
+        # con dos puntos. Se toma SIEMPRE la PRIMERA ocurrencia (find usa re.search)
+        # porque el bloque en PESOS va antes; que cuadre_interno salga 0.00 confirma
+        # que los cuatro totales salieron del MISMO bloque.
+
     elif banco == 'BANORTE':
         # Banorte SEPARA las salidas en el resumen (Total de retiros, Comisiones,
         # IVA, Intereses Cobrados/Pagados, ISR), asi que 'Total de retiros' NO es el
@@ -315,7 +412,7 @@ def extraer(path, _todo=False):
     cuadre = None
     if None not in (si, sf, dep, ret):
         cuadre = round((si + dep - ret) - sf, 2)
-    return {
+    r = {
         'banco': banco,
         'moneda': moneda,
         'depositos': dep,
@@ -325,6 +422,9 @@ def extraer(path, _todo=False):
         'cuadre_interno': cuadre,   # ~0 confirma que los totales del banco son consistentes
         'ok': ok,
     }
+    if saldo_promedio is not None:
+        r['saldo_promedio'] = saldo_promedio
+    return r
 
 
 def main():