Update fill_template.py

fill_template.py

@@ -232,6 +232,87 @@ STOPWORDS = {
 
 PERMITIDAS_CORTAS = {'Y', 'DE', 'LA', 'EL', 'SA', 'CV', 'RL', 'SC', 'AC', 'S'}
 
+# --- Movimientos SIN contraparte: se resumen por su NATURALEZA, no por nombre ---
+# El usuario pide que todo lo que aluda a efectivo diga 'EFECTIVO' (antes caia en
+# 'SIN IDENTIFICAR' porque EFECTIVO/DEPOSITO/CAJERO estan en STOPWORDS: en
+# SANTANDER eran 63 movimientos, entre ellos 'DEPOSITO EN EFECTIVO' x36).
+EFECTIVO_RE = re.compile(
+    r'RETIRO\s+SIN\s+TARJETA|SIN\s+TARJETA|EN\s+EFECTIVO|DE\s+EFECTIVO|'
+    r'\bEFECTIVO\b|DISPOSICION\s+(?:DE\s+)?EFECTIVO|RETIRO\s+CAJERO|'
+    r'\bCAJERO\b|\bATM\b|\bPRACTICAJA\b|PRACTIC\b|\bVENTANILLA\b|'
+    r'RETIRO\s+EN\s+SUCURSAL|DEP[O0]SITO\s+SUCURSAL', re.I)
+# Otros movimientos que tampoco tienen contraparte (son del propio banco/SAT).
+# El orden importa: se evalua de arriba hacia abajo.
+NATURALEZA = [
+    ('EFECTIVO',            EFECTIVO_RE),
+    ('ISR',                 re.compile(r'\bI\s*S\s*R\b|IMPUESTO\s+SOBRE\s+LA\s+RENTA|RETENCION\s+ISR', re.I)),
+    ('IVA',                 re.compile(r'\bI\s*V\s*A\b|\bVV\s+AA\b', re.I)),
+    ('COMISIONES',          re.compile(r'COMISION|MEMBRESIA|ANUALIDAD|MANEJO\s+DE\s+CUENTA', re.I)),
+    ('INTERESES',           re.compile(r'\bINTERES(?:ES)?\b|RENDIMIENTO(?:S)?\s+PAGADO', re.I)),
+    ('TRASPASO PROPIO',     re.compile(r'MISMO\s+TITULAR|TRASPASO\s+ENTRE\s+CUENTAS|CUENTA\s+PROPIA', re.I)),
+]
+# OJO: aqui NO van 'PAGO DE SERVICIOS' ni 'DOMICILIACION'. Esos SI tienen
+# contraparte (CFE, TELMEX, la aseguradora...) y el usuario quiere saber DE QUIEN
+# fue el movimiento: colapsarlos en una etiqueta generica escondia 128 y 63
+# movimientos de SANTANDER bajo un mismo nombre.
+
+
+def _naturaleza(raw):
+    """Etiqueta corta para movimientos sin contraparte. '' si no aplica."""
+    for etiqueta, rx in NATURALEZA:
+        if rx.search(raw):
+            return etiqueta
+    return ''
+
+
+def _ultimo_recurso(raw):
+    """Etiqueta para movimientos donde el banco NO da contraparte. Se aplica solo
+    DESPUES de que fallaron todas las reglas de nombre, para que un nombre real
+    siempre gane. Casos medidos en BBVA (60 de 686 caian en 'SIN IDENTIFICAR')."""
+    # Pago de impuestos: el SAT es la contraparte, pero 'S.A.T.' se pierde al
+    # quitar la puntuacion (queda 'S A T', tres tokens de 1 letra).
+    if re.search(r'\bS\.A\.T\.?|\bSAT\b|SERVICIO\s+DE\s+ADMINISTRACION\s+TRIBUTARIA', raw):
+        return 'SAT'
+    # Pago a la tarjeta de credito del propio cliente: no hay tercero. (22 casos)
+    if re.search(r'PAGO\s+TARJETA\s+DE\s+CREDITO|PAGO\s+A\s+TARJETA', raw):
+        return 'TARJETA DE CREDITO'
+    # Cobro automatico de un prestamo: el numero de recibo identifica el credito,
+    # asi que se conserva (se repite mes con mes y agrupa solo).
+    m = re.search(r'RECIBO\s+PREST\.?\s*(\d{6,})', raw)
+    if m:
+        return 'PRESTAMO ' + m.group(1)
+    m = re.search(r'\bPREST\w*\s+(\d{6,})', raw)
+    if m:
+        return 'PRESTAMO ' + m.group(1)
+    # BBVA 'PAGO CUENTA DE TERCERO BNET <ref> pago': el ordenante no escribio
+    # nombre. La referencia BNET es del movimiento, no del tercero, asi que usarla
+    # crearia un nombre distinto por operacion; se agrupan en una sola etiqueta.
+    if re.search(r'CUENTA\s+DE\s+TERCERO', raw):
+        return 'TERCERO SIN NOMBRE'
+    # Si al menos se sabe el banco contraparte, decirlo es mejor que no decir nada.
+    for b in BANCOS_TOKENS:
+        if b in raw:
+            return b
+    return ''
+
+
+def _resumen_crudo(raw):
+    """Ultimo recurso: resume el concepto en algo LEGIBLE en vez de devolver
+    'SIN IDENTIFICAR'. Quita bancos, digitos y puntuacion, tira las stopwords y
+    se queda con las palabras con sustancia. Solo devuelve '' si de verdad no
+    quedo nada (concepto vacio o puros numeros)."""
+    s = raw
+    for b in BANCOS_TOKENS:
+        s = s.replace(b, ' ')
+    s = re.sub(r'[^A-ZÑ&\s]', ' ', s)
+    toks, vistos = [], set()
+    for t in s.split():
+        if len(t) < 3 or t in STOPWORDS or t in vistos:
+            continue
+        vistos.add(t)
+        toks.append(t)
+    return ' '.join(toks[:6])[:60].strip()
+
 
 def _con_sustancia(r):
     return any(len(t) >= 3 and t not in PERMITIDAS_CORTAS for t in r)
@@ -272,6 +353,14 @@ def extraer_nombre(concepto, tipo=''):
     """
     raw = quitar_acentos(str(concepto or '').upper())
 
+    # 0) Movimientos SIN contraparte (efectivo, comisiones, IVA/ISR, intereses,
+    #    servicios): se resumen por su NATURALEZA. Va PRIMERO porque un
+    #    'RETIRO SIN TARJETA' o un 'DEPOSITO EN EFECTIVO' no tienen de quien
+    #    sacar un nombre y antes terminaban en 'SIN IDENTIFICAR'.
+    nat = _naturaleza(raw)
+    if nat:
+        return nat
+
     # 1) contraparte explicita por NOMBRE (Santander/Banorte SPEI: 'DEL CLIENTE X',
     #    'AL CLIENTE X', 'A FAVOR DE X').
     m = re.search(r'\b(?:DEL CLIENTE|AL CLIENTE|A FAVOR DE)\s+(.*)$', raw)
@@ -311,6 +400,18 @@ def extraer_nombre(concepto, tipo=''):
         if cand:
             return cand
 
+    # 6) SPEI generico: el banco imprime primero las REFERENCIAS (clave de rastreo,
+    #    CLABE, folio: bloques largos de digitos) y AL FINAL el nombre de la
+    #    contraparte. Se toma el texto que sigue al ULTIMO bloque de 10+ digitos.
+    #    Ej: 'SPEI RECIBIDOMULTIVA BANC 0000121PAGO HONORARIOS LOMAS
+    #    00132180000009445645 26021595130297 ARUAL MEDICINA DE REANIMACION'
+    #    -> 'ARUAL MEDICINA DE REANIMACION'.
+    if 'SPEI' in raw or 'TRANSFERENCIA' in raw:
+        cola = re.split(r'\d{10,}', raw)[-1]
+        cand = _primer_nombre(cola)
+        if cand and len(cand.split()) >= 2:
+            return cand
+
     # 3) heuristica general: ultima corrida con 2+ palabras (si no, la mas larga)
     s = raw
     for b in BANCOS_TOKENS:
@@ -330,7 +431,10 @@ def extraer_nombre(concepto, tipo=''):
         runs.append(run)
     runs = [r for r in runs if _con_sustancia(r)]
     if not runs:
-        return 'SIN IDENTIFICAR'
+        # Antes se devolvia 'SIN IDENTIFICAR' aunque el concepto TUVIERA texto util
+        # (el Sheet lo mostraba bien y la maqueta no). Ahora solo se rinde si de
+        # verdad no quedo nada legible.
+        return _resumen_crudo(raw) or _ultimo_recurso(raw) or 'SIN IDENTIFICAR'
     candidata = None
     for r in reversed(runs):
         if len(r) >= 2:
@@ -339,7 +443,8 @@ def extraer_nombre(concepto, tipo=''):
     if candidata is None:
         candidata = max(runs, key=len)
     candidata = candidata[-6:]
-    return ' '.join(candidata)[:60].strip() or 'SIN IDENTIFICAR'
+    return (' '.join(candidata)[:60].strip()
+            or _resumen_crudo(raw) or _ultimo_recurso(raw) or 'SIN IDENTIFICAR')
 
 
 # ---------------------------------------------------------------- principal
@@ -402,10 +507,33 @@ def fill(template_path, output_path, data):
         for t in txs:
             if t[clave_monto] > 0:
                 tot[t['nombre']] = tot.get(t['nombre'], 0.0) + t[clave_monto]
-        if len(tot) <= DESGLOSE_CAPACIDAD:
-            return {n: n for n in tot}
-        principales = set(sorted(tot, key=lambda n: -tot[n])[:DESGLOSE_CAPACIDAD - 1])
-        return {n: (n if n in principales else etiqueta_otros) for n in tot}
+
+        # --- Fusion de variantes del MISMO nombre -------------------------------
+        # El PDF corta la razon social en distinto punto segun cuanto texto la
+        # precede, asi que el mismo cliente aparece como 'EXPORTACIONES TEXTIL' y
+        # 'EXPORTACIONES TEXTILES MEXICANAS'. Se fusionan solo cuando la clave
+        # canonica de uno es PREFIJO de la del otro y mide >= 12 caracteres: es
+        # conservador a proposito (fusionar de mas atribuiria dinero a la
+        # contraparte equivocada, que es peor que dejar dos filas separadas).
+        canon = {n: re.sub(r'[^A-Z0-9]', '', quitar_acentos(n).upper()) for n in tot}
+        rep = {}
+        for n in sorted(tot, key=lambda x: (-len(canon[x]), x)):     # del mas largo al mas corto
+            cn = canon[n]
+            destino = n
+            if len(cn) >= 12:
+                for m in rep:
+                    if canon[m].startswith(cn) or cn.startswith(canon[m]):
+                        destino = rep[m]
+                        break
+            rep[n] = destino
+        fusionado = {}
+        for n, dest in rep.items():
+            fusionado[dest] = fusionado.get(dest, 0.0) + tot[n]
+
+        if len(fusionado) <= DESGLOSE_CAPACIDAD:
+            return {n: rep[n] for n in tot}
+        principales = set(sorted(fusionado, key=lambda n: -fusionado[n])[:DESGLOSE_CAPACIDAD - 1])
+        return {n: (rep[n] if rep[n] in principales else etiqueta_otros) for n in tot}
 
     mapa_dep = _mapa_nombres('deposito', 'OTROS DEPOSITANTES')
     mapa_ret = _mapa_nombres('retiro', 'OTROS BENEFICIARIOS')
@@ -764,19 +892,325 @@ def fill(template_path, output_path, data):
     }
 
 
+def _hojas_por_nombre(contenido):
+    """{nombre de hoja -> 'xl/worksheets/sheetN.xml'} resuelto por los rels.
+
+    NO se puede asumir que la hoja N-esima del libro sea sheetN.xml: el orden de
+    las pestanas y el numero de archivo son independientes (en la plantilla de
+    microempresa '00_VisitaFisica' es sheet7.xml y '07_EC_Raw' es sheet8.xml).
+    """
+    wbx = contenido['xl/workbook.xml'].decode('utf-8')
+    relsx = contenido['xl/_rels/workbook.xml.rels'].decode('utf-8')
+    rels = {}
+    for m in re.finditer(r'<Relationship\b[^>]*>', relsx):
+        tag = m.group(0)
+        rid = re.search(r'Id="([^"]+)"', tag)
+        tgt = re.search(r'Target="([^"]+)"', tag)
+        if rid and tgt:
+            rels[rid.group(1)] = tgt.group(1).lstrip('/')
+    hojas = {}
+    for m in re.finditer(r'<sheet\b[^>]*>', wbx):
+        tag = m.group(0)
+        nom = re.search(r'name="([^"]+)"', tag)
+        rid = re.search(r'r:id="([^"]+)"', tag)
+        if nom and rid and rid.group(1) in rels:
+            destino = rels[rid.group(1)]
+            if not destino.startswith('xl/'):
+                destino = 'xl/' + destino
+            hojas[unescape_xml(nom.group(1))] = destino
+    return hojas
+
+
+def unescape_xml(s):
+    from xml.sax.saxutils import unescape
+    return unescape(s, {'&quot;': '"', '&apos;': "'"})
+
+
+# Columnas de 07_EC_Raw en la plantilla de microempresa. Ojo: Categoria(E),
+# Deposito(F) y Retiro(G) son COLUMNAS CALCULADAS de Tabla_EC (derivan de Tipo y
+# Monto), y Mes(I)/Anio(J)/MesAnio(K)/Saldo(M) tambien son formulas. Excel solo
+# las autorrellena al editar de forma interactiva, asi que al escribir el XML hay
+# que emitir la formula en CADA fila o esas columnas quedan vacias y toda la
+# maqueta lee ceros.
+MICRO_RAW_HOJA = '07_EC_Raw'
+MICRO_EC_HOJA = '04_EstadosCuenta'
+MICRO_PORTADA_HOJA = '01_Portada'
+MICRO_F = {                       # formulas por fila de 07_EC_Raw
+    'E': 'IF(Tabla_EC[[#This Row],[Tipo]]="Depósito","Ingreso","Egreso")',
+    'F': 'IF(Tabla_EC[[#This Row],[Categoria]]="Ingreso",Tabla_EC[[#This Row],[Monto]],0)',
+    'G': 'IF(Tabla_EC[[#This Row],[Categoria]]="Egreso",Tabla_EC[[#This Row],[Monto]],0)',
+    'I': 'IF(Tabla_EC[[#This Row],[Fecha]]="","",TEXT(Tabla_EC[[#This Row],[Fecha]], "mmm"))',
+    'J': 'IF(Tabla_EC[[#This Row],[Fecha]]="","",YEAR(Tabla_EC[[#This Row],[Fecha]]))',
+    'K': ('IF(Tabla_EC[[#This Row],[Fecha]]="","",TEXT(Tabla_EC[[#This Row],[Fecha]], "mm")'
+          ' & " " & YEAR(Tabla_EC[[#This Row],[Fecha]]))'),
+}
+# Filas de 04_EstadosCuenta que se escriben (el resto son formulas SUMIFS/COUNTIFS
+# que leen 07_EC_Raw y se recalculan solas).
+MICRO_ROW_MES = 7          # C7 = primer mes de la ventana (D7..H7 son EDATE)
+MICRO_ROW_SALDO_INI = 8    # C8 = saldo inicial (D8..H8 = saldo final anterior)
+MICRO_ROW_SALDO_PROM = 12  # C12:H12 = saldo promedio del mes (vacias en la plantilla)
+MICRO_COLS = ['C', 'D', 'E', 'F', 'G', 'H']
+
+
+def fill_microempresa(template_path, output_path, data):
+    """Llena EXPEDIENTE_FINANCIERO_V1.5 MICROEMPRESA.xlsx.
+
+    A diferencia de la maqueta V3 anterior, esta plantilla SI tiene hoja de datos
+    crudos ('07_EC_Raw', con Tabla_EC A1:M) y su hoja 04_EstadosCuenta calcula
+    todo con SUMIFS/COUNTIFS sobre ella. Asi que el llenado es el mismo concepto
+    que la maqueta estandar: se vuelcan TODOS los movimientos y la maqueta se
+    calcula sola. Solo se escriben ademas el primer mes de la ventana, el saldo
+    inicial, el saldo promedio por mes y los datos del solicitante.
+    """
+    cliente = data.get('cliente', 'CLIENTE_SIN_NOMBRE')
+    cliente_raw = data.get('cliente_raw', cliente)
+    rfc = str(data.get('rfc', '') or '').strip()
+    transacciones = data.get('transacciones', []) or []
+    saldos_in = data.get('saldos', []) or []
+    if not isinstance(transacciones, list):
+        raise ValueError("'transacciones' debe ser una lista")
+
+    src = Path(template_path)
+    if not src.exists():
+        raise FileNotFoundError('Template no existe: %s' % template_path)
+    shutil.copy(str(src), output_path)
+
+    # ===== 1) Normalizar (sin filtrar, igual que la maqueta estandar) =====
+    txs = []
+    for t in transacciones:
+        f = parse_fecha(t.get('Fecha'))
+        if not f:
+            continue
+        dep = abs(parse_num(t.get('Deposito')))
+        ret = abs(parse_num(t.get('Retiro')))
+        concepto = str(t.get('Concepto', '') or '').strip()
+        tipo = str(t.get('Tipo', '') or '').strip()
+        txs.append({
+            'fecha': f,
+            'nombre': extraer_nombre(concepto),
+            # La columna calculada Categoria compara Tipo="Depósito". Se normaliza
+            # para que el acento y la forma coincidan siempre; los demas tipos
+            # (COMISION, DEVOLUCION, SIN_IMPORTE) caen en "Egreso", que es correcto.
+            'tipo': 'Depósito' if (dep > 0 and ret == 0) else (tipo or 'Retiro'),
+            'banco': str(t.get('Banco', '') or 'N/A').strip(),
+            'monto': round(dep if dep > 0 else ret, 2),
+            'dep': round(dep, 2),
+            'ret': round(ret, 2),
+            'moneda': (str(t.get('Moneda', '') or 'MXN').strip().upper() or 'MXN'),
+        })
+    txs.sort(key=lambda x: x['fecha'])
+
+    # tope de nombres distintos, igual que en la maqueta estandar
+    def _mapa(clave, etiqueta):
+        tot = {}
+        for t in txs:
+            if t[clave] > 0:
+                tot[t['nombre']] = tot.get(t['nombre'], 0.0) + t[clave]
+        canon = {n: re.sub(r'[^A-Z0-9]', '', quitar_acentos(n).upper()) for n in tot}
+        rep = {}
+        for n in sorted(tot, key=lambda x: (-len(canon[x]), x)):
+            destino = n
+            if len(canon[n]) >= 12:
+                for m in rep:
+                    if canon[m].startswith(canon[n]) or canon[n].startswith(canon[m]):
+                        destino = rep[m]
+                        break
+            rep[n] = destino
+        fus = {}
+        for n, dst in rep.items():
+            fus[dst] = fus.get(dst, 0.0) + tot[n]
+        if len(fus) <= DESGLOSE_CAPACIDAD:
+            return {n: rep[n] for n in tot}
+        top = set(sorted(fus, key=lambda n: -fus[n])[:DESGLOSE_CAPACIDAD - 1])
+        return {n: (rep[n] if rep[n] in top else etiqueta) for n in tot}
+
+    mapa_dep = _mapa('dep', 'OTROS DEPOSITANTES')
+    mapa_ret = _mapa('ret', 'OTROS BENEFICIARIOS')
+
+    # ===== 2) Ventana de 6 meses y saldo inicial ancla =====
+    meses = sorted({t['fecha'].strftime('%Y-%m') for t in txs})
+    ventana = meses[-6:]
+    fuera = meses[:-6]
+    sal_por_mes = {}
+    prom_por_mes = {}
+    for s in saldos_in:
+        m = str(s.get('mes', ''))
+        if not re.match(r'^\d{4}-\d{2}$', m):
+            continue
+        if s.get('saldo_inicial') not in (None, ''):
+            sal_por_mes[m] = parse_num(s.get('saldo_inicial'))
+        if s.get('saldo_promedio') not in (None, ''):
+            prom_por_mes[m] = parse_num(s.get('saldo_promedio'))
+    ancla = None
+    for m in ventana:
+        if m in sal_por_mes:
+            ancla = sal_por_mes[m]
+            break
+    # saldo promedio por mes: el del banco si lo reporta, si no el punto medio
+    # del saldo corrido de ese mes.
+    por_mes = {m: [0.0, 0.0] for m in ventana}
+    for t in txs:
+        m = t['fecha'].strftime('%Y-%m')
+        if m in por_mes:
+            por_mes[m][0] += t['dep']
+            por_mes[m][1] += t['ret']
+    corrido = ancla if ancla is not None else 0.0
+    prom_calc = {}
+    for m in ventana:
+        ini = corrido
+        fin = round(ini + por_mes[m][0] - por_mes[m][1], 2)
+        prom_calc[m] = round((ini + fin) / 2, 2)
+        corrido = fin
+
+    # ===== 3) Abrir el xlsx y resolver hojas POR NOMBRE =====
+    zin = zipfile.ZipFile(output_path, 'r')
+    contenido = {i.filename: zin.read(i.filename) for i in zin.infolist()}
+    infos = {i.filename: i for i in zin.infolist()}
+    zin.close()
+    hojas = _hojas_por_nombre(contenido)
+    for req in (MICRO_RAW_HOJA, MICRO_EC_HOJA, MICRO_PORTADA_HOJA):
+        if req not in hojas:
+            raise ValueError('La plantilla no tiene la hoja %r (hojas: %s)'
+                             % (req, sorted(hojas)))
+
+    # ===== 4) 07_EC_Raw: TODOS los movimientos =====
+    raw = contenido[hojas[MICRO_RAW_HOJA]].decode('utf-8')
+    est = {c: get_style(raw, '%s2' % c) for c in 'ABCDEFGHIJKLM'}
+    filas_xml = []
+    for i, t in enumerate(txs, start=2):
+        nombre = (mapa_dep if t['dep'] > 0 else mapa_ret).get(t['nombre'], t['nombre'])
+        celdas = [
+            build_cell('A%d' % i, s=est['A'], num=str(serial(t['fecha']))),
+            build_cell('B%d' % i, s=est['B'], text=nombre[:250]),
+            build_cell('C%d' % i, s=est['C'], text=t['tipo']),
+            build_cell('D%d' % i, s=est['D'], text=t['banco']),
+            build_cell('E%d' % i, s=est['E'], formula=MICRO_F['E']),
+            build_cell('F%d' % i, s=est['F'], formula=MICRO_F['F']),
+            build_cell('G%d' % i, s=est['G'], formula=MICRO_F['G']),
+            build_cell('H%d' % i, s=est['H'], num=t['monto']),
+            build_cell('I%d' % i, s=est['I'], formula=MICRO_F['I']),
+            build_cell('J%d' % i, s=est['J'], formula=MICRO_F['J']),
+            build_cell('K%d' % i, s=est['K'], formula=MICRO_F['K']),
+            build_cell('L%d' % i, s=est['L'], text=t['moneda']),
+            # Saldo corrido: la primera fila arranca del saldo inicial del banco.
+            build_cell('M%d' % i, s=est['M'],
+                       formula=('%s+Tabla_EC[[#This Row],[Deposito]]'
+                                '-Tabla_EC[[#This Row],[Retiro]]'
+                                % (num_str(ancla) if (i == 2 and ancla is not None)
+                                   else ('M%d' % (i - 1)) if i > 2 else '0'))),
+        ]
+        filas_xml.append('<row r="%d">%s</row>' % (i, ''.join(celdas)))
+    raw = replace_sheet_data_rows(raw, filas_xml, keep_row1=True)
+    last_row = max(2, 1 + len(txs))
+    raw = re.sub(r'<dimension ref="[^"]*"/>', '<dimension ref="A1:M%d"/>' % last_row, raw)
+    contenido[hojas[MICRO_RAW_HOJA]] = raw.encode('utf-8')
+
+    # Tabla_EC al numero real de filas
+    tbl = contenido[TABLE_EC].decode('utf-8')
+    tbl = re.sub(r'(<table [^>]*?ref=")[^"]*(")', r'\g<1>A1:M%d\g<2>' % last_row, tbl)
+    tbl = re.sub(r'(<autoFilter [^>]*?ref=")[^"]*(")', r'\g<1>A1:M%d\g<2>' % last_row, tbl)
+    contenido[TABLE_EC] = tbl.encode('utf-8')
+
+    # ===== 5) 04_EstadosCuenta =====
+    ec = desharear_formulas(contenido[hojas[MICRO_EC_HOJA]].decode('utf-8'))
+    # DEFECTO DE LA PLANTILLA: los SUMIFS de Depositos/Retiros/Efectivo cierran el
+    # mes con '"<=" & EDATE(C$7,1)', o sea INCLUYEN el dia 1 del mes siguiente, asi
+    # que todo movimiento fechado el dia 1 se suma en DOS meses. Los COUNTIFS de
+    # al lado (# Depositos / # Retiros) ya usan '"<"', que es lo correcto.
+    # Medido con 6 estados de BANAMEX: +$517,344.11 en depositos y +$192,332.71 en
+    # retiros contra lo que reporta el banco. Se corrige aqui para que la maqueta
+    # cuadre; conviene arreglarlo tambien en la plantilla de origen.
+    n_fix = ec.count('"&lt;=" &amp; EDATE(')
+    ec = ec.replace('"&lt;=" &amp; EDATE(', '"&lt;" &amp; EDATE(')
+    # los SUMIFS/COUNTIFS escanean 07_EC_Raw hasta $2167: se amplia si hay mas filas
+    def _ampliar(m):
+        return ':$%s$%d' % (m.group(1), max(int(m.group(2)), last_row))
+    ec = re.sub(r':\$([A-Z]{1,3})\$(\d{3,6})\b', _ampliar, ec)
+    if ventana:
+        y0, m0 = int(ventana[0][:4]), int(ventana[0][5:7])
+        ec = set_row_cells(ec, MICRO_ROW_MES, {
+            'C': build_cell('C%d' % MICRO_ROW_MES,
+                            s=get_style(ec, 'C%d' % MICRO_ROW_MES),
+                            num=str(serial(date(y0, m0, 1))))})
+        if ancla is not None:
+            ec = set_row_cells(ec, MICRO_ROW_SALDO_INI, {
+                'C': build_cell('C%d' % MICRO_ROW_SALDO_INI,
+                                s=get_style(ec, 'C%d' % MICRO_ROW_SALDO_INI),
+                                num=round(ancla, 2))})
+        for i, m in enumerate(ventana):
+            col = MICRO_COLS[i]
+            ec = set_row_cells(ec, MICRO_ROW_SALDO_PROM, {
+                col: build_cell('%s%d' % (col, MICRO_ROW_SALDO_PROM),
+                                s=get_style(ec, '%s%d' % (col, MICRO_ROW_SALDO_PROM)),
+                                num=prom_por_mes.get(m, prom_calc[m]))})
+        for i in range(len(ventana), 6):     # meses sin estado -> vacio
+            col = MICRO_COLS[i]
+            ec = set_row_cells(ec, MICRO_ROW_SALDO_PROM, {
+                col: build_cell('%s%d' % (col, MICRO_ROW_SALDO_PROM),
+                                s=get_style(ec, '%s%d' % (col, MICRO_ROW_SALDO_PROM)))})
+    contenido[hojas[MICRO_EC_HOJA]] = ec.encode('utf-8')
+
+    # ===== 6) 01_Portada: C9 nombre, C10 RFC, C14 fecha de analisis =====
+    por = desharear_formulas(contenido[hojas[MICRO_PORTADA_HOJA]].decode('utf-8'))
+    por = set_row_cells(por, 9, {'C': build_cell('C9', s=get_style(por, 'C9'),
+                                                 text=str(cliente_raw).upper())})
+    # El RFC se escribe SIEMPRE (aunque venga vacio) para no dejar el de ejemplo.
+    por = set_row_cells(por, 10, {'C': build_cell('C10', s=get_style(por, 'C10'),
+                                                  text=rfc.upper() if rfc else '')})
+    por = set_row_cells(por, 14, {'C': build_cell('C14', s=get_style(por, 'C14'),
+                                                  num=str(serial(date.today())))})
+    contenido[hojas[MICRO_PORTADA_HOJA]] = por.encode('utf-8')
+
+    # ===== 7) recalculo al abrir =====
+    contenido.pop('xl/calcChain.xml', None)
+    wbx = contenido['xl/workbook.xml'].decode('utf-8')
+    if '<calcPr' in wbx:
+        wbx = re.sub(r'<calcPr[^>]*/>', '<calcPr calcId="191029" fullCalcOnLoad="1"/>', wbx)
+    else:
+        wbx = wbx.replace('</workbook>',
+                          '<calcPr calcId="191029" fullCalcOnLoad="1"/></workbook>')
+    contenido['xl/workbook.xml'] = wbx.encode('utf-8')
+    ct = contenido['[Content_Types].xml'].decode('utf-8')
+    ct = re.sub(r'<Override[^>]*calcChain[^>]*/>', '', ct)
+    contenido['[Content_Types].xml'] = ct.encode('utf-8')
+
+    zout = zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED)
+    for nombre, blob in contenido.items():
+        if nombre == 'xl/calcChain.xml':
+            continue
+        zi = infos.get(nombre)
+        zout.writestr(zi if zi is not None else nombre, blob)
+    zout.close()
+
+    return {
+        'output': output_path,
+        'plantilla': 'microempresa',
+        'rows_written': len(txs),
+        'ventana_meses': ventana,
+        'meses_fuera_ventana': fuera,
+        'saldo_inicial_ancla': ancla,
+        'ordenantes_detectados': len(set(mapa_dep.values())),
+        'beneficiarios_detectados': len(set(mapa_ret.values())),
+        'sumifs_corregidos': n_fix,   # '<=' -> '<' en el cierre de mes (ver nota)
+        'cliente': cliente,
+    }
+
+
 def main():
     if len(sys.argv) < 2:
-        print(json.dumps({"error": "Uso: fill_template.py <output_path> [template_path]"}))
+        print(json.dumps({"error": "Uso: fill_template.py <output_path> [template_path] [--microempresa]"}))
         sys.exit(1)
-    output_path = sys.argv[1]
-    template_path = sys.argv[2] if len(sys.argv) > 2 else DEFAULT_TEMPLATE
+    argv = [a for a in sys.argv[1:] if a != '--microempresa']
+    micro = '--microempresa' in sys.argv
+    output_path = argv[0]
+    template_path = argv[1] if len(argv) > 1 else DEFAULT_TEMPLATE
     try:
         data = json.load(sys.stdin)
     except Exception as e:
         print(json.dumps({"error": "JSON invalido por stdin: %s" % e}))
         sys.exit(1)
     try:
-        result = fill(template_path, output_path, data)
+        result = (fill_microempresa if micro else fill)(template_path, output_path, data)
         print(json.dumps(result, ensure_ascii=False))
     except Exception as e:
         import traceback
@@ -785,4 +1219,4 @@ def main():
 
 
 if __name__ == '__main__':
-    main()
+    main()