""" compare_block_methods.py ------------------------ Compara dos métodos de clasificación de bloque defensivo: SIMPLE: phaseLabel dominante por posesión, filtro ≥3 eventos de bloque totales. Sin reglas extra. Global = toda la liga. FILTRADO: phaseLabel con desempate ≥3 eventos, filtro ≥3 eventos clave (pase/tiro), multi-bloque con pesos para posesiones largas (≥7 pases), reclasificación High→Med, y regla heurística para posesiones sin etiqueta. Solo partidos de Racing (requiere raw events). """ import ast import warnings from pathlib import Path import numpy as np import pandas as pd import plotly.graph_objects as go from plotly.subplots import make_subplots warnings.filterwarnings("ignore") PREPROCESSED = Path("/Users/pagrois/Documents/Racing/preprocessed_SSD_25-26.csv") RAW_DIR = Path("/Users/pagrois/Documents/Racing/raw_events") REPORTS_DIR = Path("/Users/pagrois/Racing/reports") REPORTS_DIR.mkdir(parents=True, exist_ok=True) DARK_BG = "#1A1F2E" CARD_BG = "#232A3B" TEXT_COLOR = "#E8EDF5" GRID_COLOR = "#2E3650" COLORS = {"High": "#E06C5F", "Medium": "#F0A500", "Low": "#00A86B"} BLOCK_LBL = {"High": "Bloque Alto", "Medium": "Bloque Medio", "Low": "Bloque Bajo"} BLOCKS = ["High", "Medium", "Low"] PHASE_TO_BLOCK = { "Build Up against High Block": "High", "Build Up against Medium Block": "Medium", "Build Up against Low Block": "Low", } PERIOD_COL = "period_id" def base_layout(**extra): d = dict(paper_bgcolor=CARD_BG, plot_bgcolor=DARK_BG, font=dict(color=TEXT_COLOR, size=11), margin=dict(l=60, r=20, t=55, b=50), legend=dict(bgcolor=CARD_BG, bordercolor=GRID_COLOR, borderwidth=1)) d.update(extra); return d def axis_style(**kw): d = dict(gridcolor=GRID_COLOR, zerolinecolor=GRID_COLOR, linecolor=GRID_COLOR) d.update(kw); return d def fig2html(fig): return fig.to_html(full_html=False, include_plotlyjs=False) # --------------------------------------------------------------------------- # 1. Cargar preprocessed — COMPLETO (toda la liga) para SIMPLE global # --------------------------------------------------------------------------- print("Cargando preprocessed (toda la liga)...", flush=True) load_cols = ["matchId", "possessionId", "phaseLabel", "TeamName", "TeamRival", "fecha", PERIOD_COL] df_pre = pd.read_csv(PREPROCESSED, usecols=load_cols, low_memory=False) df_pre["fecha_str"] = df_pre["fecha"].str[:10] df_pre["block_raw"] = df_pre["phaseLabel"].map(PHASE_TO_BLOCK) df_pre["matchId"] = df_pre["matchId"].astype(str) df_pre["possessionId"] = df_pre["possessionId"].astype(float).astype(str) df_pre[PERIOD_COL] = pd.to_numeric(df_pre[PERIOD_COL], errors="coerce") df_pre = df_pre[df_pre[PERIOD_COL].isin([1, 2])] print(f" {df_pre['matchId'].nunique()} partidos totales en preprocessed") # Subconjunto Racing (para FILTRADO y gráficos por partido) racing_mask = (df_pre["TeamName"].str.contains("Racing de Santander", na=False) | df_pre["TeamRival"].str.contains("Racing de Santander", na=False)) df_racing = df_pre[racing_mask].copy() has_label_mids = set(df_racing.dropna(subset=["block_raw"])["matchId"]) match_dates = (df_racing[df_racing["matchId"].isin(has_label_mids)] .groupby("matchId")["fecha_str"].first().sort_values()) all_racing_ids = match_dates.index.tolist() match_info = {} for mid in all_racing_ids: r = df_racing[df_racing["matchId"] == mid].iloc[0] home = r["TeamName"]; away = r["TeamRival"] rival = away if "Racing" in home else home match_info[mid] = { "home": home, "away": away, "fecha": r["fecha_str"], "rival": rival.replace("Racing de Santander", "Racing"), "label": r["fecha_str"] + " " + rival.replace("Racing de Santander","Racing")[:16], } print(f" {len(all_racing_ids)} partidos Racing con etiquetas phaseLabel") df_ar = df_racing[df_racing["matchId"].isin(all_racing_ids)].copy() all_poss = (df_ar.dropna(subset=["possessionId"]) .groupby(["matchId","possessionId"])[["TeamName", PERIOD_COL]] .first().reset_index()) # --------------------------------------------------------------------------- # 2. Raw events Racing — para FILTRADO y filtro key_ok # --------------------------------------------------------------------------- print("\nCargando raw events Racing...", flush=True) SHOT_EVENTS = {"SavedShot","MissedShots","Goal","ShotOnPost","KeeperSweeper"} def n_opts(v): if pd.isna(v): return 0 try: d = ast.literal_eval(str(v)) return len(d.get("player",[])) if isinstance(d, dict) else 0 except: return 0 # Lookup por nombre completo del archivo (maneja múltiples partidos por fecha) xlsx_all_files = list(RAW_DIR.glob("*.xlsx")) def find_xlsx(fecha, home, away): """Busca el xlsx del partido por fecha y equipos.""" h_sub = home.lower()[:10] a_sub = away.lower()[:10] for f in xlsx_all_files: if not f.stem.startswith(fecha): continue rest = f.stem[13:].lower() # "HomeTeam vs AwayTeam" if h_sub in rest or a_sub in rest: return f return None raw_stats = {} for i, mid in enumerate(all_racing_ids, 1): fpath = find_xlsx(match_info[mid]["fecha"], match_info[mid]["home"], match_info[mid]["away"]) if not fpath: continue if i % 8 == 0 or i == len(all_racing_ids): print(f" {i}/{len(all_racing_ids)} {fpath.name}", flush=True) df_ev = pd.read_excel(fpath, sheet_name="Eventos", engine="openpyxl") df_ev = df_ev[df_ev["possessionId"].notna()].copy() df_ev["matchId"] = str(mid) df_ev["possessionId"] = df_ev["possessionId"].astype(float).astype(str) df_ev["x_val"] = pd.to_numeric(df_ev.get("x", pd.Series(dtype=float)), errors="coerce") df_ev["is_key"] = df_ev["event_name"].isin({"Pass"} | SHOT_EVENTS) df_ev["is_pass"] = df_ev["event_name"] == "Pass" df_ev["has_press"] = df_ev["pressure"].notna() if "pressure" in df_ev.columns else False df_ev["n_opt"] = df_ev["passOption"].apply(n_opts) if "passOption" in df_ev.columns else 0 for (m, p), grp in df_ev.groupby(["matchId","possessionId"]): press_grp = grp[grp["has_press"] & grp["x_val"].notna()] n_press_own = int((press_grp["x_val"] < 50).sum()) pass_rival = grp[grp["is_pass"] & grp["x_val"].notna() & (grp["x_val"] > 50)] pass_7opt = int((pass_rival["n_opt"] >= 7).sum()) pass_own = grp[grp["is_pass"] & grp["x_val"].notna() & (grp["x_val"] < 50)] max_opts_own = int(pass_own["n_opt"].max()) if len(pass_own) > 0 else 0 raw_stats[(m, p)] = { "n_passes": int(grp["is_pass"].sum()), "pass_7opt_rival": pass_7opt, "max_opts_own": max_opts_own, "n_press_own": n_press_own, "n_key_events": int(grp["is_key"].sum()), } key_ok = {(m, p) for (m, p), s in raw_stats.items() if s.get("n_key_events", 0) >= 3} # --------------------------------------------------------------------------- # 3. MÉTODO SIMPLE — toda la liga, filtro ≥3 eventos de bloque totales # --------------------------------------------------------------------------- print("\nMétodo SIMPLE (toda la liga)...", flush=True) block_ev_global = (df_pre.dropna(subset=["block_raw","possessionId"]) .groupby(["matchId","possessionId","block_raw"]) .size().reset_index(name="n_ev")) simple_global_rows = [] for (mid, pid), grp in block_ev_global.groupby(["matchId","possessionId"]): if grp["n_ev"].sum() < 3: continue dominant = grp.loc[grp["n_ev"].idxmax(), "block_raw"] simple_global_rows.append({"matchId": mid, "possessionId": pid, "block": dominant, "weight": 1.0}) df_simple_global = pd.DataFrame(simple_global_rows) if simple_global_rows else pd.DataFrame( columns=["matchId","possessionId","block","weight"]) print(f" {len(df_simple_global):,} posesiones clasificadas (liga completa)") # SIMPLE Racing (mismo filtro, para gráficos por partido) block_ev_racing = (df_ar.dropna(subset=["block_raw","possessionId"]) .groupby(["matchId","possessionId","block_raw"]) .size().reset_index(name="n_ev")) simple_rows = [] for (mid, pid), grp in block_ev_racing.groupby(["matchId","possessionId"]): if (mid, pid) not in key_ok: continue dominant = grp.loc[grp["n_ev"].idxmax(), "block_raw"] simple_rows.append({"matchId": mid, "possessionId": pid, "block": dominant, "weight": 1.0}) df_simple = pd.DataFrame(simple_rows) if simple_rows else pd.DataFrame( columns=["matchId","possessionId","block","weight"]) df_simple = df_simple.merge(all_poss, on=["matchId","possessionId"], how="left") df_simple["is_racing_att"] = df_simple["TeamName"].str.contains("Racing de Santander", na=False) print(f" {len(df_simple):,} posesiones Racing clasificadas") # --------------------------------------------------------------------------- # 4. MÉTODO FILTRADO — Racing, con pesos para posesiones largas (≥7 pases) # --------------------------------------------------------------------------- print("\nMétodo FILTRADO (Racing)...", flush=True) comp_ev = block_ev_racing.rename(columns={"block_raw":"block_type"}) def resolve_blocks(grp): max_n = grp["n_ev"].max() tied = set(grp[grp["n_ev"] == max_n]["block_type"]) if len(tied) == 1: return list(tied) valid = set(grp[(grp["n_ev"] >= 3) & grp["block_type"].isin(tied)]["block_type"]) blocks = list(valid) if valid else list(tied) if len(blocks) > 1 and "Medium" in blocks: non_med = [b for b in blocks if b != "Medium"] if non_med: blocks = non_med return blocks filt_rows = [] for (mid, pid), grp in comp_ev.groupby(["matchId","possessionId"]): n_passes = raw_stats.get((mid, pid), {}).get("n_passes", 0) total_block_ev = grp["n_ev"].sum() if n_passes >= 7 and len(grp) > 1: # Posesión larga: permite múltiples bloques con peso proporcional for _, row in grp.iterrows(): filt_rows.append({ "matchId": mid, "possessionId": pid, "block": row["block_type"], "weight": row["n_ev"] / total_block_ev, }) else: blocks = resolve_blocks(grp) w = 1.0 / len(blocks) for b in blocks: filt_rows.append({"matchId": mid, "possessionId": pid, "block": b, "weight": w}) df_fx_labeled = pd.DataFrame(filt_rows) if filt_rows else pd.DataFrame( columns=["matchId","possessionId","block","weight"]) labeled_poss = set(zip(df_fx_labeled["matchId"], df_fx_labeled["possessionId"])) # Regla heurística para posesiones sin etiqueta rule_rows = [] for _, row in all_poss.iterrows(): mid, pid = row["matchId"], row["possessionId"] if (mid, pid) in labeled_poss: continue s = raw_stats.get((mid, pid), {}) if s.get("n_passes", 0) <= 3: continue # High: presiona arriba O defensor empujó ≥5 jugadores al campo de Racing is_high = s["n_press_own"] > 3 or s.get("max_opts_own", 0) >= 5 b = "Low" if s["pass_7opt_rival"] >= 2 else ("High" if is_high else "Medium") rule_rows.append({"matchId": mid, "possessionId": pid, "block": b, "weight": 1.0}) df_fx_all = pd.concat([df_fx_labeled, pd.DataFrame(rule_rows) if rule_rows else pd.DataFrame( columns=["matchId","possessionId","block","weight"])], ignore_index=True) df_fx_all = df_fx_all.merge(all_poss, on=["matchId","possessionId"], how="left") df_fx_all["is_racing_att"] = df_fx_all["TeamName"].str.contains("Racing de Santander", na=False) # Filtro ≥3 eventos clave df_fx_all = df_fx_all[df_fx_all.apply( lambda r: (r["matchId"], r["possessionId"]) in key_ok, axis=1)].copy() # Reclasificación High→Med: 0 presiones propias Y defensor sin ≥5 jugadores en campo Racing df_fx_all["n_press_own"] = df_fx_all.apply( lambda r: raw_stats.get((r["matchId"],r["possessionId"]),{}).get("n_press_own",0), axis=1) df_fx_all["max_opts_own"] = df_fx_all.apply( lambda r: raw_stats.get((r["matchId"],r["possessionId"]),{}).get("max_opts_own",0), axis=1) matches_with_press = {m for (m,p),s in raw_stats.items() if s.get("n_press_own",0) > 0} mask_am = (df_fx_all["block"] == "High") & \ (df_fx_all["n_press_own"] < 1) & \ (df_fx_all["max_opts_own"] < 5) & \ (df_fx_all["matchId"].isin(matches_with_press)) df_fx_all.loc[mask_am, "block"] = "Medium" reclassif_am = int(mask_am.sum()) n_poss_fx = df_fx_all[["matchId","possessionId"]].drop_duplicates().shape[0] print(f" Reclasificados High→Med: {reclassif_am}") print(f" {n_poss_fx:,} posesiones únicas Racing clasificadas (con multi-bloque: {len(df_fx_all):,} filas)") # --------------------------------------------------------------------------- # 5. Funciones de distribución con pesos # --------------------------------------------------------------------------- def weighted_dist(df): """Distribución porcentual usando weights. Retorna dict {block: pct} y n únicas posesiones.""" total_w = df["weight"].sum() if total_w == 0: return {b: 0.0 for b in BLOCKS}, 0 dist = {b: 100 * df[df["block"] == b]["weight"].sum() / total_w for b in BLOCKS} n = df[["matchId","possessionId"]].drop_duplicates().shape[0] return dist, n def global_dist(df, role_val): sub = df[df["is_racing_att"] == role_val] return weighted_dist(sub) def global_dist_all(df): """Distribución sin filtro por rol (para toda la liga).""" return weighted_dist(df) def dist_by_match(df, role_val): sub = df[df["is_racing_att"] == role_val].copy() rows = [] for mid in all_racing_ids: m_sub = sub[sub["matchId"] == mid] total_w = max(m_sub["weight"].sum(), 1e-9) rows.append({ "matchId": mid, "label": match_info[mid]["label"], "total": m_sub[["matchId","possessionId"]].drop_duplicates().shape[0], **{b: 100 * m_sub[m_sub["block"] == b]["weight"].sum() / total_w for b in BLOCKS} }) return pd.DataFrame(rows) # Distribuciones globales simple_global_dist, simple_global_n = global_dist_all(df_simple_global) simple_att_dist, simple_att_n = global_dist(df_simple, True) simple_def_dist, simple_def_n = global_dist(df_simple, False) fx_att_dist, fx_att_n = global_dist(df_fx_all, True) fx_def_dist, fx_def_n = global_dist(df_fx_all, False) # % que difiere (por possessionId único, tomando el bloque mayoritario) def dominant_block(grp): return grp.loc[grp["weight"].idxmax(), "block"] simple_dom = (df_simple.groupby(["matchId","possessionId"]) .apply(dominant_block).reset_index(name="block_simple")) fx_dom = (df_fx_all.groupby(["matchId","possessionId"]) .apply(dominant_block).reset_index(name="block_fx")) merged = simple_dom.merge(fx_dom, on=["matchId","possessionId"], how="inner") differ = (merged["block_simple"] != merged["block_fx"]).sum() total_shared = len(merged) print(f"\n Posesiones en común: {total_shared:,} | Difieren: {differ:,} ({100*differ/max(total_shared,1):.1f}%)") # --------------------------------------------------------------------------- # 6. Gráficos # --------------------------------------------------------------------------- print("\nGenerando gráficos...", flush=True) # ── Fig 1: Distribución global — donuts ───────────────────────────────────── # Fila 1: toda la liga (SIMPLE) + Racing Racing ataca/defiende (SIMPLE y FILTRADO) fig1 = make_subplots( rows=1, cols=5, specs=[[{"type":"domain"}]*5], subplot_titles=[ "SIMPLE — Toda la liga", "SIMPLE — Racing ataca", "SIMPLE — Racing defiende", "FILTRADO — Racing ataca", "FILTRADO — Racing defiende", ] ) for col, (dist, n) in enumerate([ (simple_global_dist, simple_global_n), (simple_att_dist, simple_att_n), (simple_def_dist, simple_def_n), (fx_att_dist, fx_att_n), (fx_def_dist, fx_def_n), ], 1): fig1.add_trace(go.Pie( labels=[BLOCK_LBL[b] for b in BLOCKS], values=[round(dist[b], 1) for b in BLOCKS], marker_colors=[COLORS[b] for b in BLOCKS], hole=0.55, textinfo="label+percent", textfont=dict(size=9, color=TEXT_COLOR), hovertemplate="%{label}: %{value:.1f}%", name=f"n={n:,}", ), row=1, col=col) col_sfx = "" if col == 1 else str(col) fig1.add_annotation( text=f"n={n:,}", showarrow=False, font=dict(size=8, color=TEXT_COLOR), xref=f"x{col_sfx} domain", yref=f"y{col_sfx} domain", x=0.5, y=0.5, ) fig1.update_layout(**base_layout( title=dict(text="Distribución global — SIMPLE (toda la liga) vs FILTRADO (Racing)", font=dict(color=TEXT_COLOR, size=13), x=0.01), height=380, )) # ── Fig 2 & 3: Por partido Racing — barras verticales apiladas ─────────────── def all_match_bar_fig(df_s, df_f, role_val, title): labels = [] vals_s = {b: [] for b in BLOCKS} vals_f = {b: [] for b in BLOCKS} for mid in all_racing_ids: short = match_info[mid]["label"] lbl = f"{short[:5]} {short[11:]}" labels.append(lbl) for df_, vals in [(df_s, vals_s), (df_f, vals_f)]: m_sub = df_[(df_["matchId"] == mid) & (df_["is_racing_att"] == role_val)] total_w = max(m_sub["weight"].sum(), 1e-9) for b in BLOCKS: vals[b].append(100 * m_sub[m_sub["block"] == b]["weight"].sum() / total_w) fig = make_subplots(rows=2, cols=1, shared_xaxes=True, subplot_titles=["SIMPLE", "FILTRADO"], vertical_spacing=0.06) for b in BLOCKS: for row, vals in [(1, vals_s), (2, vals_f)]: texts = [f"{v:.0f}%" if v >= 8 else "" for v in vals[b]] fig.add_trace(go.Bar( name=BLOCK_LBL[b], x=labels, y=vals[b], marker_color=COLORS[b], text=texts, textposition="inside", textfont=dict(size=8, color="white"), showlegend=(row == 1), legendgroup=b, ), row=row, col=1) fig.update_layout(**base_layout( title=dict(text=title, font=dict(color=TEXT_COLOR, size=13), x=0.01), barmode="stack", height=700, xaxis2=dict(**axis_style(tickangle=-45, tickfont=dict(size=8))), yaxis=dict(**axis_style(title="% posesiones", range=[0,100])), yaxis2=dict(**axis_style(title="% posesiones", range=[0,100])), )) return fig fig2 = all_match_bar_fig(df_simple, df_fx_all, True, "Por partido — Racing ATACA") fig3 = all_match_bar_fig(df_simple, df_fx_all, False, "Por partido — Racing DEFIENDE") # ── Fig 4: Posesiones que difieren por partido ────────────────────────────── merged_m = merged.merge(all_poss[["matchId","possessionId","TeamName"]], on=["matchId","possessionId"], how="left") diff_per_match = (merged_m.groupby("matchId") .apply(lambda g: pd.Series({ "total": len(g), "difieren": (g["block_simple"] != g["block_fx"]).sum(), })).reset_index()) diff_per_match["pct"] = 100 * diff_per_match["difieren"] / diff_per_match["total"].clip(lower=1) diff_per_match["label"] = diff_per_match["matchId"].map(lambda m: match_info.get(m,{}).get("label","?")) diff_per_match = diff_per_match.sort_values("matchId") fig4 = go.Figure() fig4.add_trace(go.Bar( x=diff_per_match["label"], y=diff_per_match["pct"], marker_color=COLORS["Medium"], text=[f"{v:.0f}%" for v in diff_per_match["pct"]], textposition="outside", textfont=dict(color=TEXT_COLOR, size=9), )) fig4.update_layout(**base_layout( title=dict(text="% posesiones con distinta clasificación entre Simple y Filtrado (Racing)", font=dict(color=TEXT_COLOR, size=13), x=0.01), height=380, xaxis=dict(**axis_style(tickangle=-45, tickfont=dict(size=8))), yaxis=dict(**axis_style(title="% difieren", range=[0,100])), )) # ── Fig 5: Matriz de transición ───────────────────────────────────────────── trans = merged.groupby(["block_simple","block_fx"]).size().reset_index(name="n") fig5 = go.Figure(go.Heatmap( x=[BLOCK_LBL[b] for b in BLOCKS], y=[BLOCK_LBL[b] for b in BLOCKS], z=[[trans[(trans["block_simple"]==bs) & (trans["block_fx"]==bc)]["n"].sum() for bc in BLOCKS] for bs in BLOCKS], colorscale="Blues", text=[[str(int(trans[(trans["block_simple"]==bs) & (trans["block_fx"]==bc)]["n"].sum())) for bc in BLOCKS] for bs in BLOCKS], texttemplate="%{text}", textfont=dict(size=12, color=TEXT_COLOR), hovertemplate="Simple=%{y}, Filtrado=%{x}: %{text}", xgap=2, ygap=2, )) fig5.update_layout(**base_layout( title=dict(text="Transición de clasificación: Simple (fila) → Filtrado (columna) — Racing", font=dict(color=TEXT_COLOR, size=13), x=0.01), height=320, xaxis=dict(**axis_style(title="Filtrado")), yaxis=dict(**axis_style(title="Simple")), )) # --------------------------------------------------------------------------- # 7. HTML # --------------------------------------------------------------------------- print("Generando HTML...", flush=True) def stat_box(label, val, color="#F0A500"): return (f'
' f'{val}' f'{label}
') html = f""" Comparación métodos de bloque — Racing

Comparación de métodos de clasificación de bloque — Racing de Santander

SIMPLE: phaseLabel dominante · filtro ≥3 eventos de bloque · sin reclasificaciones · Global = toda la liga ({df_pre['matchId'].nunique()} partidos)
FILTRADO: phaseLabel con desempate (≥3 eventos) · filtro ≥3 eventos clave (pase/tiro) · posesiones largas (≥7 pases) con múltiples bloques ponderados · High→Med si 0 presiones propias Y defensor sin ≥5 jugadores en campo Racing · heurística para posesiones sin etiqueta (Low si ≥2 pases con ≥7 opciones en campo rival; High si >3 presiones propias o defensor empujó ≥5 jugadores) · Solo partidos Racing ({len(all_racing_ids)} partidos)
{stat_box("SIMPLE — toda la liga", f"{simple_global_n:,}")} {stat_box("SIMPLE — Racing ataca", f"{simple_att_n:,}")} {stat_box("SIMPLE — Racing defiende", f"{simple_def_n:,}")} {stat_box("FILTRADO — Racing ataca", f"{fx_att_n:,}")} {stat_box("FILTRADO — Racing defiende", f"{fx_def_n:,}")} {stat_box("En común (Racing)", f"{total_shared:,}")} {stat_box("Difieren", f"{differ:,} ({100*differ/max(total_shared,1):.1f}%)", "#E06C5F")} {stat_box("Reclasif. High→Med", f"{reclassif_am:,}")}

1. Distribución global — donuts

Primer donut: SIMPLE aplicado a toda la liga (filtro ≥3 eventos de bloque por phaseLabel, sin raw events).
Resto: comparación SIMPLE vs FILTRADO en partidos de Racing. FILTRADO permite múltiples bloques ponderados en posesiones largas.

{fig2html(fig1)}

2. Por partido — Racing ataca (Simple arriba · Filtrado abajo)

{fig2html(fig2)}

3. Por partido — Racing defiende (Simple arriba · Filtrado abajo)

{fig2html(fig3)}

4. % posesiones con clasificación distinta entre métodos (Racing)

Calculado sobre posesiones en común usando el bloque de mayor peso.

{fig2html(fig4)}

5. Matriz de transición Simple → Filtrado (Racing)

Fila = clasificación Simple · Columna = clasificación Filtrado · valores = n posesiones

{fig2html(fig5)}
""" out = REPORTS_DIR / "comparacion_metodos_bloque.html" out.write_text(html, encoding="utf-8") print(f"\nReporte: {out}")