"""RS1 · 60 · segunda implementación (§9): pandas + pyarrow, SIN DuckDB (imagen licitaciones-scrapers:vps). Clave del BORME con la impl2 de E-M3 (nn, borme_norm_de_nn); tramos y enlaces con bucles de Python. Compara (a) conectado por par y (b) K, N por celda.""" import sys, os, re, json, time, glob, datetime as dt, collections sys.path.insert(0, '/e3'); sys.path.insert(0, '/w/py') import numpy as np, pandas as pd, pyarrow as pa, pyarrow.parquet as pq, pyarrow.compute as pc from em3_impl2 import nn, borme_norm_de_nn, solo_az09 from comun_roles import ADM, SOC, APO T0 = time.time() def log(*a): print(f"[{time.time()-T0:7.1f}s]", *a, flush=True) INI = dt.date(2009, 1, 2); FINC = dt.date(2026, 2, 17); FIND = dt.date(2026, 10, 16) cache_bn = {} def bn_de(e): if e not in cache_bn: cache_bn[e] = borme_norm_de_nn(nn(e)) or '' return cache_bn[e] # ---- sociedades de la celda sat = pd.read_parquet('/et/em3/salidas/unified_20261018.borme/empresas.parquet') e5 = pd.read_parquet('/et/em5/salidas/17_etiquetas_INTERNO.parquet', columns=['empresa_clave', 'etiqueta']) sat = sat.merge(e5, on='empresa_clave', how='left') soc = sat[sat.via.isin(['v1_exacto', 'v2_historico']) & sat.utilizable.fillna(False) & (sat.etiqueta.fillna('') != 'R')] emp2bn = dict(zip(soc.empresa_clave, soc.borme_norm)); BN = set(soc.borme_norm) fext = soc.dropna(subset=['fecha_extincion']).groupby('borme_norm').fecha_extincion.min().to_dict() fext = {k: (v.date() if hasattr(v, 'date') else v) for k, v in fext.items()} log('soc', len(soc), len(BN)) # ---- cargos t = pq.read_table('/b/parse/borme_cargos.parquet', columns=['empresa', 'fecha_borme', 'tipo_acto', 'cargo', 'persona_hash']) t = t.filter(pc.is_valid(t['persona_hash'])) cg = t['cargo'].combine_chunks().dictionary_encode() clase_de = {} for v in cg.dictionary.to_pylist(): c = solo_az09(v) if v is not None else '' clase_de[v] = 'adm' if c in ADM else 'soc' if c in SOC else 'apo' if c in APO else None cl_arr = pa.array([clase_de[v] for v in cg.dictionary.to_pylist()]) clase = pc.take(cl_arr, cg.indices) t = t.append_column('clase', clase).filter(pc.is_valid(clase)) em = t['empresa'].combine_chunks().dictionary_encode() bn_dict = [bn_de(v) if v is not None else '' for v in em.dictionary.to_pylist()] df = pd.DataFrame({'bn': pd.Categorical.from_codes(em.indices.to_numpy(zero_copy_only=False), categories=pd.Index(bn_dict).unique()) if False else np.array(bn_dict, dtype=object)[em.indices.to_numpy(zero_copy_only=False)], 'h': t['persona_hash'].to_pandas(), 'tipo': t['tipo_acto'].to_pandas(), 'clase': t['clase'].to_pandas(), 'd': pd.to_datetime(t['fecha_borme'].to_pandas()).dt.date}) del t, em, cg log('cargos incluidos', len(df)) nemp = df[df.bn != ''].groupby('h').bn.nunique().to_dict() df = df[df.bn.isin(BN)].copy() log('cargos celda', len(df)) # eventos por día df['op'] = df.tipo.isin(['nombramiento', 'reeleccion']); df['cl'] = df.tipo.isin(['cese', 'revocacion', 'cancelacion']) ev = df.groupby(['bn', 'h', 'clase', 'd'], sort=True).agg(op=('op', 'any'), cl=('cl', 'any')).reset_index() tramos = [] # (bn, h, clase, desde, hasta) for (bn, h, c), g in ev.groupby(['bn', 'h', 'clase'], sort=False): estado = None; ini = None for d, op in zip(g.d, g.op): st = 1 if op else 0 if st == 1 and estado != 1: ini = d elif st == 0 and estado is None: tramos.append([bn, h, c, INI, d]) elif st == 0 and estado == 1: tramos.append([bn, h, c, ini, d]); ini = None estado = st if estado == 1: tramos.append([bn, h, c, ini, min(fext.get(bn, FINC) or FINC, FINC)]) log('tramos', len(tramos)) # socio único: cierre por otro socio único o por pérdida de unipersonalidad pe = pq.read_table('/b/parse/borme_empresas.parquet', columns=['empresa', 'fecha_borme', 'actos', 'domicilio']).to_pandas() pe['bn'] = [bn_de(e) if e is not None else '' for e in pe.empresa] pe['d'] = pd.to_datetime(pe.fecha_borme).dt.date rx = re.compile(r'rdida del car.*cter de unipersonalidad', re.I) perd = collections.defaultdict(list) for bn, d, a in zip(pe.bn, pe.d, pe.actos): if bn in BN and a and rx.search(a): perd[bn].append(d) socini = collections.defaultdict(list) for r in tramos: if r[2] == 'soc': socini[r[0]].append((r[3], r[1])) for r in tramos: if r[2] != 'soc': continue c = [d for d, h in socini[r[0]] if h != r[1] and d > r[3]] + [d for d in perd.get(r[0], []) if d > r[3]] if c: r[4] = min(r[4], min(c)) # ---- domicilios pe = pe[(pe.domicilio.fillna('') != '')] pe['k'] = [solo_az09(v) for v in pe.domicilio] nsoc = pe[pe.k.str.len() >= 8].groupby('k').bn.nunique().to_dict() pd1 = pe[pe.bn.isin(BN)].groupby(['bn', 'd']).k.max().reset_index().sort_values(['bn', 'd']) dtr = [] for bn, g in pd1.groupby('bn', sort=False): seq = [] for d, k in zip(g.d, g.k): if not seq or seq[-1][1] != k: seq.append([d, k]) for i, (d, k) in enumerate(seq): hasta = seq[i + 1][0] if i + 1 < len(seq) else min(fext.get(bn, FIND) or FIND, FIND) dtr.append((bn, k, d, hasta)) del pe log('dtramos', len(dtr)) # índices per_bn = collections.defaultdict(lambda: collections.defaultdict(list)) # bn -> h -> [(desde, hasta)] (n_emp <= 20) cualquier_cargo = collections.defaultdict(list) for bn, h, c, a, b in tramos: cualquier_cargo[bn].append((a, b)) if nemp.get(h, 0) <= 20: per_bn[bn][h].append((a, b)) dom_bn = collections.defaultdict(lambda: collections.defaultdict(list)); cualquier_dom = collections.defaultdict(list) for bn, k, a, b in dtr: cualquier_dom[bn].append((a, b)) if nsoc.get(k, 99) < 10: dom_bn[bn][k].append((a, b)) def conectado(x1, x2, w0, w1): for idx in (per_bn, dom_bn): A, B = idx.get(x1, {}), idx.get(x2, {}) if len(A) > len(B): A, B = B, A for key, la in A.items(): lb = B.get(key) if not lb: continue for a0, a1 in la: for b0, b1 in lb: o0, o1 = max(a0, b0), min(a1, b1) if o0 <= o1 and o0 <= w1 and o1 >= w0: return True return False # ---- (a) pa_ = pd.read_parquet('/w/interno/30_pares.parquet') pa_['c1'] = (pa_.np20 > 0) | pa_.dom pa_['c2'] = [conectado(a, b, dt.date(y0, 1, 1), dt.date(y1, 12, 31)) for a, b, y0, y1 in zip(pa_.bnA, pa_.bnB, pa_.a0, pa_.a1)] dif_a = int((pa_.c1 != pa_.c2).sum()) log('(a) pares', len(pa_), 'diferencias', dif_a, 'pos conectados impl1/impl2', int(pa_[pa_.pos == 1].c1.sum()), int(pa_[pa_.pos == 1].c2.sum())) # ---- universo de lotes (CO1) desde los parquet COLS = ['id_canonical', 'licitacion_id', 'organo_nif', 'organo_nombre', 'dir3', 'cpv_division', 'anio_ref', 'adjudicatario_nif_raw', 'adjudicatario_nif', 'adjudicatario_nombre', 'unidad', 'es_menor', 'es_menor_dudoso', 'copia_de', 'correccion_imp_adj', 'anulado_en_origen'] partes = [] for f in sorted(glob.glob('/d/unified_20261018/*/*/*.parquet')): src = f.split('/')[3].split('=', 1)[1] sch = pq.read_schema(f).names tb = pq.read_table(f, columns=[c for c in COLS if c in sch]).to_pandas() for c in COLS: if c not in tb: tb[c] = None def fb(c): return tb[c].fillna(False).astype(bool) m = (tb.unidad == 'adjudicacion') & ~fb('es_menor') & ~fb('es_menor_dudoso') & tb.copia_de.isna() & (tb.correccion_imp_adj.fillna('') != 'copia_otra_fuente') \ & ~fb('anulado_en_origen') & tb.anio_ref.between(2012, 2025) tb = tb[m] if len(tb): tb['source'] = src; partes.append(tb[['source'] + COLS[:10]]) L = pd.concat(partes, ignore_index=True); del partes log('lotes', len(L)) I = '/d/unified_20261018.identidad/' of = pd.read_parquet(I + 'organos_filas.parquet', columns=['organo_nif', 'organo_nombre', 'dir3', 'organo_clave']).drop_duplicates(['organo_nif', 'organo_nombre', 'dir3']) af = pd.read_parquet(I + 'adjudicatarios_filas.parquet', columns=['adjudicatario_nif_raw', 'adjudicatario_nif', 'adjudicatario_nombre', 'empresa_clave', 'persona_fisica']) af['pf'] = af.persona_fisica.fillna(False).astype(bool) af = af.groupby(['adjudicatario_nif_raw', 'adjudicatario_nif', 'adjudicatario_nombre'], dropna=False).agg(empresa_clave=('empresa_clave', 'first'), pf=('pf', 'any')).reset_index() L = L.merge(of, on=['organo_nif', 'organo_nombre', 'dir3'], how='left').merge(af, on=['adjudicatario_nif_raw', 'adjudicatario_nif', 'adjudicatario_nombre'], how='left') L = L[L.empresa_clave.notna() & ~L.pf.fillna(False).astype(bool)] us = pd.read_parquet(I + 'ute_socios.parquet') us = us[us.socio_nif.notna() & ~us.socio_persona_fisica.fillna(False).astype(bool)][['ute_clave', 'socio_nif']].drop_duplicates() L = L.merge(us, left_on='empresa_clave', right_on='ute_clave', how='left') L['via_ute'] = L.ute_clave.notna(); L['emp'] = L.socio_nif.where(L.via_ute, L.empresa_clave) L['lic'] = L.source + '|' + L.licitacion_id.fillna(L.id_canonical) L = L[L.organo_clave.notna() & L.cpv_division.notna()] L['bn'] = L.emp.map(emp2bn); L = L[L.bn.notna()] L = L[['source', 'id_canonical', 'lic', 'organo_clave', 'cpv_division', 'anio_ref', 'bn', 'via_ute']].drop_duplicates() def toca(lst, y): a, b = dt.date(y, 1, 1), dt.date(y, 12, 31) return any(x0 <= b and x1 >= a for x0, x1 in lst) evc = {} def evaluable(bn, y): k = (bn, y) if k not in evc: evc[k] = toca(cualquier_cargo.get(bn, []), y) or toca(cualquier_dom.get(bn, []), y) return evc[k] L = L[[evaluable(b, int(y)) for b, y in zip(L.bn, L.anio_ref)]] log('lse', len(L), L.drop_duplicates(['source', 'id_canonical']).shape[0]) L['lote'] = L.source + '|' + L.id_canonical herm = set() for lic, g in L.groupby('lic', sort=False): if g.bn.nunique() < 2: continue filas = list(zip(g.lote, g.bn, g.anio_ref, g.via_ute)) for l1, b1, y1, u1 in filas: if l1 in herm: continue for l2, b2, y2, u2 in filas: if b2 == b1 or (l1 == l2 and u1 and u2): continue if conectado(b1, b2, dt.date(int(y1), 1, 1), dt.date(int(y1), 12, 31)): herm.add(l1); break L['h'] = L.lote.isin(herm) c2 = L.groupby(['organo_clave', 'cpv_division', 'anio_ref']).apply(lambda g: pd.Series({'N2': g.lote.nunique(), 'K2': g[g.h].lote.nunique()}), include_groups=False).reset_index() c1 = pd.read_parquet('/w/interno/40_celda.parquet').rename(columns={'cpv2': 'cpv_division', 'anio': 'anio_ref'}) c1['anio_ref'] = c1.anio_ref.astype(int); c2['anio_ref'] = c2.anio_ref.astype(int) m = c1.merge(c2, on=['organo_clave', 'cpv_division', 'anio_ref'], how='outer') for c in ('N', 'K', 'N2', 'K2'): m[c] = m[c].fillna(0) dN = int((m.N != m.N2).sum()); dK = int((m.K != m.K2).sum()); dH = int(((m.K > 0) != (m.K2 > 0)).sum()) R = {'motor': f'pandas {pd.__version__}, pyarrow {pa.__version__}, sin DuckDB', 'a_pares': len(pa_), 'a_diferencias': dif_a, 'a_pos_conectados': [int(pa_[(pa_.pos == 1) & (pa_['var'] == 'dec')].c1.sum()), int(pa_[(pa_.pos == 1) & (pa_['var'] == 'dec')].c2.sum())], 'b_celdas': len(m), 'b_dif_N': dN, 'b_dif_K': dK, 'b_dif_hecho': dH, 'b_K_total': [int(m.K.sum()), int(m.K2.sum())], 'b_N_total': [int(m.N.sum()), int(m.N2.sum())], 'b_celdas_hecho': [int((m.K > 0).sum()), int((m.K2 > 0).sum())]} R['pct_dif_a'] = round(100 * dif_a / len(pa_), 4); R['pct_dif_b'] = round(100 * max(dN, dK) / len(m), 4) R['veredicto'] = 'PASA' if R['pct_dif_a'] <= 0.5 and R['pct_dif_b'] <= 0.5 else 'NO PASA' json.dump(R, open('/w/interno/60_impl2.json', 'w'), indent=1); log(R) if dif_a: pa_[pa_.c1 != pa_.c2][['pid', 'pos', 'c1', 'c2']].to_parquet('/w/interno/60_dif_a.parquet') if dN or dK: m[(m.N != m.N2) | (m.K != m.K2)].to_parquet('/w/interno/60_dif_b.parquet')