from __future__ import annotations import argparse import json import random import colorsys import re from dataclasses import dataclass, field import copy from pathlib import Path from typing import Any, Dict, List, Optional, Tuple from PIL import Image, ImageDraw, ImageFont from name_pools import CONFIG_FLAG_POOL from config_tag import build_config_info, embed_code_in_image # ========================= # ========================= @dataclass class PTCell: row: int col: int row_span: int = 1 col_span: int = 1 text: str = "" value: Optional[float] = None kind: str = "data" # header/group/item/data bbox: Optional[Tuple[int, int, int, int]] = None extra: Dict[str, str] = field(default_factory=dict) @dataclass class TableSpec: n_rows: int n_cols: int header_rows: int data_row_start: int left_cols: int top_levels: int left_levels: int cells: List[PTCell] data_cols: List[Dict] delta_col: Optional[int] = None # ========================= # ========================= def _auto_font_path() -> Optional[str]: candidates = [ "/usr/share/fonts/truetype/dejavu/DejaVuSerif.ttf", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", "/usr/share/fonts/truetype/liberation/LiberationSerif-Regular.ttf", "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf", ] for p in candidates: if Path(p).exists(): return p return None def _auto_symbol_font_candidates() -> List[str]: return [ "/usr/share/fonts/truetype/noto/NotoSansSymbols2-Regular.ttf", "/usr/share/fonts/truetype/noto/NotoSansSymbols-Regular.ttf", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", "/usr/share/fonts/truetype/dejavu/DejaVuSerif.ttf", "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf", "/usr/share/fonts/truetype/liberation/LiberationSerif-Regular.ttf", ] def _pick_font_for_text(paths: List[str], text: str, size: int) -> Optional[ImageFont.FreeTypeFont]: for p in paths: if not Path(p).exists(): continue try: f = ImageFont.truetype(p, size) mask = f.getmask(text) if mask.getbbox(): return f except Exception: continue return None def _format_delta(v: float) -> str: sign = "+" if v >= 0 else "−" return f"{sign}{abs(v):.2f}" def _clear_style_marks(cells: List[PTCell]) -> None: for c in cells: if isinstance(c.extra, dict): c.extra.pop("highlight", None) c.extra.pop("highlight_color", None) c.extra.pop("highlight_color_name", None) c.extra.pop("underline", None) c.extra.pop("bold", None) def _metric_prefers_lower(metric_text: Optional[str]) -> bool: t = str(metric_text or "") return "↓" in t def _metric_text_by_col_index(col_idx: int, *, left_cols: int, col_metrics: Optional[List[str]]) -> str: if not col_metrics: return "" rel = int(col_idx) - int(left_cols) if 0 <= rel < len(col_metrics): return str(col_metrics[rel] or "") return "" def _pick_best_cell_by_metric(vals: List[PTCell], metric_text: Optional[str]) -> PTCell: if _metric_prefers_lower(metric_text): return min(vals, key=lambda x: x.value) # type: ignore[arg-type] return max(vals, key=lambda x: x.value) # type: ignore[arg-type] def _sort_cells_for_metric(vals: List[PTCell], metric_text: Optional[str]) -> None: vals.sort(key=lambda x: x.value, reverse=(not _metric_prefers_lower(metric_text))) # type: ignore[call-arg] def _apply_highlight_by_column_rank( cells: List[PTCell], *, left_cols: int, data_cols_len: int, colors: List[str], col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] if not data_cells: return palette = list(colors) if colors else ["#E6F2FF", "#BFD8FF", "#7FAEFF"] palette_rev = list(reversed(palette)) for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) _sort_cells_for_metric(vals, metric_text) top_k = min(len(palette_rev), len(vals)) for i in range(top_k): c = vals[i] c.extra["highlight"] = "true" c.extra["highlight_color"] = palette_rev[i].upper() def _apply_highlight_by_column_wrong( rng: random.Random, cells: List[PTCell], *, left_cols: int, data_cols_len: int, colors: List[str], col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] if not data_cells: return palette = list(colors) if colors else ["#FFD2E6"] for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) best = _pick_best_cell_by_metric(vals, metric_text) pool = [c for c in vals if c is not best] if not pool: continue c = rng.choice(pool) c.extra["highlight"] = "true" c.extra["highlight_color"] = rng.choice(palette).upper() def _apply_highlight_best_per_col( cells: List[PTCell], *, left_cols: int, data_cols_len: int, color_hex: str, col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] if not data_cells: return hx = str(color_hex).upper() for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) best = _pick_best_cell_by_metric(vals, metric_text) best.extra["highlight"] = "true" best.extra["highlight_color"] = hx def _apply_underline_best_per_col( cells: List[PTCell], *, left_cols: int, data_cols_len: int, col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) best = _pick_best_cell_by_metric(vals, metric_text) best.extra["underline"] = "true" def _apply_underline_wrong_per_col( rng: random.Random, cells: List[PTCell], *, left_cols: int, data_cols_len: int, col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) best = _pick_best_cell_by_metric(vals, metric_text) pool = [c for c in vals if c is not best] if not pool: continue rng.choice(pool).extra["underline"] = "true" def _apply_underline_second_per_col( cells: List[PTCell], *, left_cols: int, data_cols_len: int, col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) vals_sorted = list(vals) _sort_cells_for_metric(vals_sorted, metric_text) second = vals_sorted[1] second.extra["underline"] = "true" def _apply_bold_best_per_col( cells: List[PTCell], *, left_cols: int, data_cols_len: int, col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) best = _pick_best_cell_by_metric(vals, metric_text) best.extra["bold"] = "true" def _apply_bold_wrong_per_col( rng: random.Random, cells: List[PTCell], *, left_cols: int, data_cols_len: int, col_metrics: Optional[List[str]] = None, ) -> None: data_cells = [c for c in cells if c.kind == "data" and c.value is not None] for col_idx in range(left_cols, left_cols + data_cols_len): vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue metric_text = _metric_text_by_col_index(col_idx, left_cols=left_cols, col_metrics=col_metrics) best = _pick_best_cell_by_metric(vals, metric_text) pool = [c for c in vals if c is not best] if not pool: continue rng.choice(pool).extra["bold"] = "true" def _apply_text_color_mark(cell: PTCell, *, color_hex: str, role: str) -> None: color_hex_u = str(color_hex).upper() cell.extra["text_color"] = "true" cell.extra["text_color_hex"] = color_hex_u cell.extra["text_color_role"] = role try: rgb = _hex_to_rgb(color_hex_u) cell.extra["text_color_name"] = _color_base_name(rgb) except Exception: cell.extra["text_color_name"] = "color" def _hex_to_rgb(h: str) -> Tuple[int, int, int]: h = h.strip().lstrip("#") if len(h) != 6: raise ValueError(f"Bad hex color: {h}") return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)) def _color_base_name(rgb: Tuple[int, int, int]) -> str: r, g, b = rgb h, s, v = colorsys.rgb_to_hsv(r / 255.0, g / 255.0, b / 255.0) # keep near-neutral colors as white/gray/black, but avoid classifying pale blue as white if s < 0.08: if v > 0.92: return "white" if v < 0.2: return "black" return "gray" deg = h * 360.0 if deg < 20 or deg >= 340: return "red" if 20 <= deg < 45: return "orange" if 45 <= deg < 70: return "yellow" if 70 <= deg < 160: return "green" if 160 <= deg < 200: return "cyan" if 200 <= deg < 250: return "blue" if 250 <= deg < 290: return "purple" return "pink" def _build_palette_color_names(colors: List[str], explicit: Optional[Dict[str, str]] = None) -> Dict[str, str]: """ Give each palette color an English name (light/medium/dark + base). """ if explicit: return {k.upper(): v for k, v in explicit.items()} items = [] for c in colors: try: rgb = _hex_to_rgb(c) except Exception: continue r, g, b = rgb h, s, v = colorsys.rgb_to_hsv(r / 255.0, g / 255.0, b / 255.0) base = _color_base_name(rgb) items.append({"hex": c.upper(), "base": base, "v": v}) by_base: Dict[str, List[Dict]] = {} for it in items: by_base.setdefault(it["base"], []).append(it) name_map: Dict[str, str] = {} for base, arr in by_base.items(): arr.sort(key=lambda x: x["v"], reverse=True) # Higher brightness means a lighter shade. n = len(arr) if n == 1: prefixes = [""] elif n == 2: prefixes = ["light", "dark"] elif n == 3: prefixes = ["light", "medium", "dark"] elif n == 4: prefixes = ["very light", "light", "dark", "very dark"] elif n == 5: prefixes = ["very light", "light", "medium", "dark", "very dark"] else: prefixes = [] for i in range(n): if i == 0: prefixes.append("very light") elif i == 1: prefixes.append("light") elif i == n - 2: prefixes.append("dark") elif i == n - 1: prefixes.append("very dark") else: prefixes.append("medium") for it, pref in zip(arr, prefixes): if pref: name_map[it["hex"]] = f"{pref} {base}" else: name_map[it["hex"]] = base return name_map def _parse_palette(s: str) -> List[str]: return [p.strip() for p in s.split(",") if p.strip()] def _parse_palettes(s: str) -> List[List[str]]: """ Parse multiple palettes: "c1,c2,c3; d1,d2,d3" -> [[c1..], [d1..]] """ palettes: List[List[str]] = [] for part in s.split(";"): part = part.strip() if not part: continue colors = _parse_palette(part) if colors: palettes.append(colors) return palettes def _clamp_int(v: int, lo: int = 1, hi: Optional[int] = None) -> int: x = int(v) if x < lo: x = lo if hi is not None and x > hi: x = hi return x def _palette_group_from_id(pid: str) -> str: if not pid: return "X" head = pid.strip()[0].upper() if head in ("A", "B", "C"): return head return "X" def _rand_name(rng: random.Random, pool: List[str], suffix: bool = True) -> str: base = rng.choice(pool) if suffix: tail = rng.choice(["A", "B", "C", "D", "E", "F", "X", "Y", "Z"]) return f"{base}-{tail}" return base def _maybe_add_arrow(rng: random.Random, metric: str, prob: float) -> str: if "↑" in metric or "↓" in metric: return metric if rng.random() > prob: return metric return metric + rng.choice(["↑", "↓"]) def _rand_metric(rng: random.Random, pool: List[str], arrow_prob: float) -> str: metric = rng.choice(pool) return _maybe_add_arrow(rng, metric, arrow_prob) def _insert_suffix_before_arrow(label: str, suffix: str) -> str: if label.endswith("↑") or label.endswith("↓"): return f"{label[:-1]}{suffix}{label[-1]}" return f"{label}{suffix}" def _sample_unique_label( rng: random.Random, used: set[str], sampler, *, fallback_prefix: str, ) -> str: for _ in range(256): cand = str(sampler()) if cand not in used: used.add(cand) return cand base = str(sampler()) for i in range(2, 10000): cand = _insert_suffix_before_arrow(base, f"-{i}") if cand not in used: used.add(cand) return cand for i in range(1, 100000): cand = f"{fallback_prefix}-{i}" if cand not in used: used.add(cand) return cand raise RuntimeError("Failed to sample a unique label") def _format_number(rng: random.Random, dec_min: int, dec_max: int) -> Tuple[str, float]: dec = rng.randint(dec_min, dec_max) v = rng.uniform(0, 100) text = f"{v:.{dec}f}" return text, float(text) def _split_citation(text: str) -> Tuple[str, str]: if "[" in text and text.endswith("]"): i = text.rfind("[") return text[:i].rstrip(), text[i:] return text, "" # ========================= # ========================= def build_paper_table( rng: random.Random, *, group_count: int, min_items: int, max_items: int, block_count: int, min_metrics: int, max_metrics: int, mid_group_min: int, mid_group_max: int, section_count: int, unique_numbers: bool, top_levels: int, left_levels: int, merge_group_prob: float, citation_prob: float, missing_prob: float, dec_min: int, dec_max: int, highlight: bool, highlight_mode: str, highlight_rate: float, highlight_count: int, highlight_colors: List[str], highlight_use_all_colors: bool, highlight_strategy: str, highlight_rank_k: int, underline_rate: float, underline_best_per_col: bool, underline_second_per_col: bool, underline_wrong_per_col: bool, bold_rate: float, bold_best_per_col: bool, bold_wrong_per_col: bool, text_color_delta_sign: bool, text_color_best_per_col: bool, text_color_pos_hex: str, text_color_neg_hex: str, text_color_best_hex: str, arrow_rate: float, arrow_up_ratio: float, data_arrows: bool, metric_arrow_prob: float, config_rows: bool, config_flag_pool: List[str], config_shade_best_row: bool, ) -> TableSpec: group_pool = ["Group", "Category", "Setting", "Scenario", "Domain", "Subset", "Task", "Condition"] item_pool = ["Method", "Model", "System", "Approach", "Variant", "Baseline"] group_header_name = rng.choice(group_pool) item_header_name = rng.choice(item_pool) groups = [] used_item_names: set[str] = set() for gi in range(group_count): gname = f"{group_header_name} {chr(65+gi)}" item_n = rng.randint(min_items, max_items) items = [] for _ in range(item_n): name = _sample_unique_label( rng, used_item_names, lambda: _rand_name(rng, item_pool, suffix=True), fallback_prefix=str(item_header_name), ) if rng.random() < citation_prob: cid = rng.randint(1, 99) name = f"{name} [{cid}]" items.append(name) groups.append({"name": gname, "items": items}) if int(left_levels) >= 2: uniq_group_names = {str(g.get("name", "")).strip() for g in groups if str(g.get("name", "")).strip()} if len(uniq_group_names) <= 1: left_levels = 1 effective_section_count = max(0, min(3, int(section_count))) if effective_section_count < 2: effective_section_count = 0 section_pool = ["Type", "Model", "Family", "Category", "Subset"] sections = [] if effective_section_count > 0: section_n = min(effective_section_count, max(1, len(groups))) base = len(groups) // section_n rem = len(groups) % section_n idx = 0 section_prefix: Optional[str] = None for si in range(section_n): size = base + (1 if si < rem else 0) chunk = groups[idx : idx + size] idx += size sampled_prefix = rng.choice(section_pool) if section_prefix is None: section_prefix = sampled_prefix sname = f"{section_prefix}-{chr(65+si)}" sections.append({"name": sname, "groups": chunk}) else: sections.append({"name": "", "groups": groups}) block_pool = ["Blk", "Grp", "Sect", "Part", "Set", "Cfg", "Zone", "Slot"] mid_pool = ["Err", "Qual", "Rate", "Score", "Cost", "Stat", "Comp", "Perf", "Gain", "Loss"] metric_pool = [ "MetA", "MetB", "MetC", "MetD", "MetE", "Score", "Val", "Idx", "Rate", "Rank", "Err", "Cost", "Eff", "Qual", "Stat", "S-A", "S-C", "S-D", ] blocks = [] used_metric_labels: set[str] = set() for bi in range(block_count): bname = f"{rng.choice(block_pool)}-{chr(65+bi)}" if top_levels == 3: mid_n = rng.randint(mid_group_min, mid_group_max) mid_groups = [] for _ in range(max(1, mid_n)): mid_name = rng.choice(mid_pool) m = rng.randint(min_metrics, max_metrics) metrics = [ _sample_unique_label( rng, used_metric_labels, lambda: _rand_metric(rng, metric_pool, metric_arrow_prob), fallback_prefix="Met", ) for _ in range(max(1, m)) ] mid_groups.append({"name": mid_name, "metrics": metrics}) blocks.append({"name": bname, "mid_groups": mid_groups}) else: m = rng.randint(min_metrics, max_metrics) metrics = [ _sample_unique_label( rng, used_metric_labels, lambda: _rand_metric(rng, metric_pool, metric_arrow_prob), fallback_prefix="Met", ) for _ in range(max(1, m)) ] blocks.append({"name": bname, "metrics": metrics}) data_cols = [] if top_levels == 3: for b in blocks: for mg in b["mid_groups"]: for m in mg["metrics"]: data_cols.append({"block": b["name"], "mid": mg["name"], "metric": m}) else: for b in blocks: for m in b["metrics"]: data_cols.append({"block": b["name"], "metric": m}) data_rows = sum(len(g["items"]) for g in groups) section_rows = 0 if effective_section_count > 0: section_rows = len(sections) n_rows = top_levels + data_rows n_rows += section_rows left_cols = max(1, int(left_levels)) n_cols = left_cols + len(data_cols) # Left label columns plus metric columns. cells: List[PTCell] = [] # 5) Header if top_levels == 3: if left_cols == 2: cells.append(PTCell(row=0, col=0, row_span=3, text=group_header_name, kind="header")) cells.append(PTCell(row=0, col=1, row_span=3, text=item_header_name, kind="header")) else: cells.append(PTCell(row=0, col=0, row_span=3, text=item_header_name, kind="header")) c = left_cols for b in blocks: span = sum(len(mg["metrics"]) for mg in b["mid_groups"]) cells.append(PTCell(row=0, col=c, col_span=span, text=b["name"], kind="header")) c += span c = left_cols for b in blocks: for mg in b["mid_groups"]: span = len(mg["metrics"]) cells.append(PTCell(row=1, col=c, col_span=span, text=mg["name"], kind="header")) c += span c = left_cols for b in blocks: for mg in b["mid_groups"]: for m in mg["metrics"]: cells.append(PTCell(row=2, col=c, text=m, kind="header")) c += 1 elif top_levels == 2: if left_cols == 2: cells.append(PTCell(row=0, col=0, row_span=2, text=group_header_name, kind="header")) cells.append(PTCell(row=0, col=1, row_span=2, text=item_header_name, kind="header")) else: cells.append(PTCell(row=0, col=0, row_span=2, text=item_header_name, kind="header")) c = left_cols for b in blocks: span = len(b["metrics"]) cells.append(PTCell(row=0, col=c, col_span=span, text=b["name"], kind="header")) c += span # Metric row c = left_cols for b in blocks: for m in b["metrics"]: cells.append(PTCell(row=1, col=c, text=m, kind="header")) c += 1 else: if left_cols == 2: cells.append(PTCell(row=0, col=0, text=group_header_name, kind="header")) cells.append(PTCell(row=0, col=1, text=item_header_name, kind="header")) else: cells.append(PTCell(row=0, col=0, text=item_header_name, kind="header")) c = left_cols used = {} idx = 0 for b in blocks: for m in b["metrics"]: base = m arrow = "" if base.endswith("↑") or base.endswith("↓"): arrow = base[-1] base = base[:-1] count = used.get(base, 0) used[base] = count + 1 if count > 0: suffix = chr(64 + min(26, count + 1)) # A,B,C... text = f"{base}{suffix}{arrow}" else: text = f"{base}{arrow}" if idx < len(data_cols): data_cols[idx]["metric"] = text idx += 1 cells.append(PTCell(row=0, col=c, text=text, kind="header")) c += 1 r = top_levels used_numbers: set[str] = set() for sec in sections: if effective_section_count > 0: cells.append(PTCell(row=r, col=0, col_span=left_cols, text=sec["name"], kind="section")) c = left_cols for colinfo in data_cols: cells.append(PTCell(row=r, col=c, text=colinfo["metric"], kind="header")) c += 1 r += 1 for g in sec["groups"]: items = g["items"] if left_cols == 2: if rng.random() < merge_group_prob: cells.append(PTCell(row=r, col=0, row_span=len(items), text=g["name"], kind="group")) for i, item in enumerate(items): cells.append(PTCell(row=r + i, col=1, text=item, kind="item")) else: for i, item in enumerate(items): cells.append(PTCell(row=r + i, col=0, text=g["name"], kind="group")) cells.append(PTCell(row=r + i, col=1, text=item, kind="item")) else: for i, item in enumerate(items): cells.append(PTCell(row=r + i, col=0, text=item, kind="item")) for i, item in enumerate(items): cidx = left_cols for col_meta in data_cols: metric_text = str(col_meta.get("metric", "")) allow_missing_here = not _metric_prefers_lower(metric_text) if allow_missing_here and (rng.random() < missing_prob): txt = rng.choice(["—", "N/A"]) val = None else: if unique_numbers: for _try in range(1000): txt, val = _format_number(rng, dec_min, dec_max) if txt not in used_numbers: used_numbers.add(txt) break else: txt, val = _format_number(rng, dec_min, dec_max) else: txt, val = _format_number(rng, dec_min, dec_max) cells.append(PTCell(row=r + i, col=cidx, text=txt, value=val, kind="data")) cidx += 1 r += len(items) delta_col: Optional[int] = None if config_rows and len(data_cols) > 0: delta_col = left_cols + len(data_cols) - 1 delta_label = rng.choice(["ΔGain↑", "ΔDiff↑", "ΔChange↑", "ΔDelta↑"]) data_cols[-1]["metric"] = delta_label for c in cells: if c.kind == "header" and c.col == delta_col and c.col_span == 1: c.text = delta_label delta_vals: Dict[int, float] = {} for c in cells: if c.kind == "data" and c.col == delta_col: base = rng.uniform(-2.5, 2.5) pm = rng.uniform(0.05, 0.80) c.text = f"{_format_delta(base)} ±{pm:.2f}" c.value = None # Keep delta annotations out of ordinary numeric tasks. c.extra["delta_col"] = True c.extra["delta_base"] = float(base) delta_vals[c.row] = float(base) if config_shade_best_row and delta_vals: best_row = max(delta_vals, key=lambda r: delta_vals[r]) for c in cells: if c.row == best_row: c.extra["shade_row"] = True data_cells = [c for c in cells if c.kind == "data" and c.value is not None] delta_cells = [c for c in cells if c.kind == "data" and c.extra.get("delta_col")] style_cells = data_cells + [c for c in delta_cells if c not in data_cells] all_data_cells = style_cells if style_cells: if highlight and highlight_strategy == "by_column_rank": palette = list(highlight_colors) if not palette: palette = ["#E6F2FF", "#BFD8FF", "#7FAEFF"] if not highlight_use_all_colors: k = highlight_rank_k if highlight_rank_k > 0 else min(3, len(palette)) palette = palette[:k] if not data_cells and delta_cells: if highlight_count > 0: k = min(highlight_count, len(delta_cells)) else: k = max(1, int(round(len(delta_cells) * max(0.0, highlight_rate)))) chosen = rng.sample(delta_cells, k=min(k, len(delta_cells))) for i, c in enumerate(chosen): color_hex = palette[i % len(palette)] if highlight_use_all_colors else rng.choice(palette) c.extra["highlight"] = "true" c.extra["highlight_color"] = color_hex.upper() else: palette_rev = list(reversed(palette)) for col_idx in range(left_cols, left_cols + len(data_cols)): metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) if delta_col is not None and col_idx == delta_col: vals = [c for c in all_data_cells if c.col == col_idx and c.extra.get("delta_col")] if not vals: continue vals.sort(key=lambda x: float(x.extra.get("delta_base", -1e9)), reverse=True) else: vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue _sort_cells_for_metric(vals, metric_text) top_k = min(len(palette_rev), len(vals)) for i in range(top_k): c = vals[i] c.extra["highlight"] = "true" c.extra["highlight_color"] = palette_rev[i].upper() elif highlight and highlight_strategy == "by_column_wrong": palette = list(highlight_colors) or ["#FFD2E6"] color_idx = 0 for col_idx in range(left_cols, left_cols + len(data_cols)): metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue best = _pick_best_cell_by_metric(vals, metric_text) pool = [c for c in vals if c is not best] if not pool: continue c = rng.choice(pool) if highlight_use_all_colors and palette: color_hex = palette[color_idx % len(palette)] color_idx += 1 else: color_hex = rng.choice(palette) c.extra["highlight"] = "true" c.extra["highlight_color"] = color_hex.upper() elif highlight: if highlight_count > 0: k = min(highlight_count, len(style_cells)) else: k = max(1, int(round(len(style_cells) * max(0.0, highlight_rate)))) mode = highlight_mode if mode == "random": mode = rng.choice(["single", "multi"]) if mode == "single": palette = [rng.choice(highlight_colors)] else: if highlight_use_all_colors: palette = list(highlight_colors) else: max_n = min(4, len(highlight_colors)) pick_n = rng.randint(2, max_n) if max_n >= 2 else 1 palette = rng.sample(highlight_colors, k=pick_n) if highlight_use_all_colors and len(palette) > 0: k = max(k, len(palette)) chosen = rng.sample(style_cells, k=min(k, len(style_cells))) for i, c in enumerate(chosen): if highlight_use_all_colors and palette: color_hex = palette[i % len(palette)] else: color_hex = rng.choice(palette) c.extra["highlight"] = "true" c.extra["highlight_color"] = color_hex.upper() allow_underline = not ( highlight and highlight_strategy == "by_column_rank" and not (underline_best_per_col or underline_second_per_col or underline_wrong_per_col) ) if allow_underline: if underline_best_per_col: for col_idx in range(left_cols, left_cols + len(data_cols)): metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) if delta_col is not None and col_idx == delta_col: vals = [c for c in all_data_cells if c.col == col_idx and c.extra.get("delta_col")] if not vals: continue best = max(vals, key=lambda x: float(x.extra.get("delta_base", -1e9))) else: vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue best = _pick_best_cell_by_metric(vals, metric_text) best.extra["underline"] = "true" elif underline_second_per_col: for col_idx in range(left_cols, left_cols + len(data_cols)): metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) if delta_col is not None and col_idx == delta_col: vals = [c for c in all_data_cells if c.col == col_idx and c.extra.get("delta_col")] if len(vals) <= 1: continue vals.sort(key=lambda x: float(x.extra.get("delta_base", -1e9)), reverse=True) vals[1].extra["underline"] = "true" else: vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue _sort_cells_for_metric(vals, metric_text) vals[1].extra["underline"] = "true" elif underline_wrong_per_col: for col_idx in range(left_cols, left_cols + len(data_cols)): metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) if delta_col is not None and col_idx == delta_col: vals = [c for c in all_data_cells if c.col == col_idx and c.extra.get("delta_col")] if len(vals) <= 1: continue best = max(vals, key=lambda x: float(x.extra.get("delta_base", -1e9))) else: vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue best = _pick_best_cell_by_metric(vals, metric_text) pool = [c for c in vals if c is not best] if not pool: continue rng.choice(pool).extra["underline"] = "true" elif underline_rate > 0: k = max(1, int(round(len(style_cells) * max(0.0, underline_rate)))) chosen = rng.sample(style_cells, k=min(k, len(style_cells))) for c in chosen: c.extra["underline"] = "true" allow_bold = not (highlight and highlight_strategy == "by_column_rank" and not (bold_best_per_col or bold_wrong_per_col)) if allow_bold: if bold_best_per_col: for col_idx in range(left_cols, left_cols + len(data_cols)): metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) if delta_col is not None and col_idx == delta_col: vals = [c for c in all_data_cells if c.col == col_idx and c.extra.get("delta_col")] if not vals: continue best = max(vals, key=lambda x: float(x.extra.get("delta_base", -1e9))) else: vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue best = _pick_best_cell_by_metric(vals, metric_text) best.extra["bold"] = "true" elif bold_wrong_per_col: for col_idx in range(left_cols, left_cols + len(data_cols)): metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) if delta_col is not None and col_idx == delta_col: vals = [c for c in all_data_cells if c.col == col_idx and c.extra.get("delta_col")] if len(vals) <= 1: continue best = max(vals, key=lambda x: float(x.extra.get("delta_base", -1e9))) else: vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if len(vals) <= 1: continue best = _pick_best_cell_by_metric(vals, metric_text) pool = [c for c in vals if c is not best] if not pool: continue rng.choice(pool).extra["bold"] = "true" elif bold_rate > 0: k = max(1, int(round(len(style_cells) * max(0.0, bold_rate)))) chosen = rng.sample(style_cells, k=min(k, len(style_cells))) for c in chosen: c.extra["bold"] = "true" if text_color_delta_sign: for c in delta_cells: base = c.extra.get("delta_base") if base is None: continue try: base_f = float(base) except Exception: continue if base_f > 0: _apply_text_color_mark(c, color_hex=text_color_pos_hex, role="delta_positive") elif base_f < 0: _apply_text_color_mark(c, color_hex=text_color_neg_hex, role="delta_negative") if text_color_best_per_col: for col_idx in range(left_cols, left_cols + len(data_cols)): if delta_col is not None and col_idx == delta_col: continue vals = [c for c in data_cells if c.col == col_idx and c.value is not None] if not vals: continue metric_text = str(data_cols[col_idx - left_cols].get("metric", "")) best = _pick_best_cell_by_metric(vals, metric_text) _apply_text_color_mark(best, color_hex=text_color_best_hex, role="best_per_col") if data_arrows and arrow_rate > 0: k = max(1, int(round(len(data_cells) * max(0.0, arrow_rate)))) chosen = rng.sample(data_cells, k=min(k, len(data_cells))) for c in chosen: c.extra["arrow"] = "up" if rng.random() < arrow_up_ratio else "down" return TableSpec( n_rows=n_rows, n_cols=n_cols, header_rows=top_levels, data_row_start=top_levels, left_cols=left_cols, top_levels=top_levels, left_levels=left_levels, cells=cells, data_cols=data_cols, delta_col=delta_col, ) # ========================= # ========================= def render_table( spec: TableSpec, *, out_path: Path, canvas_width: int, canvas_height: int, margins: Tuple[int, int, int, int], font_path: Optional[str], font_size: int, line_style: str, # none | grid | three-line | sparse-grid block_sep: bool, number_align: str, arrow_offset: Tuple[int, int], arrow_scale: float, delta_pm_scale: float = 1.00, crop_to_table: bool = True, crop_pad: int = 12, ) -> None: left, top, right, bottom = margins avail_w = canvas_width - left - right avail_h = canvas_height - top - bottom fpath = font_path or _auto_font_path() if fpath and Path(fpath).exists(): font = ImageFont.truetype(fpath, font_size) else: font = ImageFont.load_default() symbol_paths = _auto_symbol_font_candidates() if fpath: symbol_paths.append(fpath) font_check = _pick_font_for_text(symbol_paths, "✓✗", int(round(font_size * 1.15))) or font _measure = ImageDraw.Draw(Image.new("RGB", (10, 10))) if spec.left_cols == 2: left_ratios = [0.14, 0.22] else: left_ratios = [0.22] data_col_count = max(1, (spec.n_cols - spec.left_cols)) pad_est = max(2, font_size // 6) col_need_px = [0 for _ in range(max(1, spec.n_cols))] delta_pm_scale = max(0.60, min(1.10, float(delta_pm_scale))) pm_size_est = max(8, int(round(font_size * delta_pm_scale))) kerning_est = max(1, pm_size_est // 12) gap_pm_est = max(2, pm_size_est // 6) if fpath and Path(fpath).exists(): try: font_pm_est = ImageFont.truetype(fpath, pm_size_est) except Exception: font_pm_est = font else: font_pm_est = font for c in spec.cells: if c.col_span != 1: continue col_idx = int(c.col) if not (0 <= col_idx < len(col_need_px)): continue txt = str(c.text or "") if not txt: continue if c.kind == "data" and "±" in txt: try: main_text, pm_text = txt.split("±", 1) main_text = main_text.strip() pm_text = "±" + pm_text.strip() tb_main = _measure.textbbox((0, 0), main_text, font=font) main_w = tb_main[2] - tb_main[0] tb_sym = _measure.textbbox((0, 0), "±", font=font_pm_est) tb_dig = _measure.textbbox((0, 0), pm_text[1:], font=font_pm_est) sym_w = tb_sym[2] - tb_sym[0] dig_w = tb_dig[2] - tb_dig[0] text_w = main_w + gap_pm_est + (sym_w + dig_w - kerning_est) except Exception: tb = _measure.textbbox((0, 0), txt, font=font) text_w = tb[2] - tb[0] else: font_obj = font_check if ("✓" in txt or "✗" in txt or c.extra.get("is_flag")) else font tb = _measure.textbbox((0, 0), txt, font=font_obj) text_w = tb[2] - tb[0] extra_pad = pad_est * 2 if c.kind in ("header", "section"): extra_pad += max(2, font_size // 8) col_need_px[col_idx] = max(col_need_px[col_idx], int(text_w + extra_pad)) col_floor_px: List[int] = [] for ci in range(spec.n_cols): if ci < spec.left_cols: if spec.left_cols == 2: floor = int(font_size * (4.8 if ci == 0 else 7.2)) else: floor = int(font_size * 6.5) else: floor = int(font_size * 4.0) if spec.delta_col is not None and ci == spec.delta_col: delta_floor_mul = 1.28 if delta_pm_scale >= 0.98 else 1.12 floor = int(round(floor * delta_floor_mul)) col_floor_px.append(max(36, floor)) natural_table_w = sum(max(col_need_px[i], col_floor_px[i]) for i in range(spec.n_cols)) if data_col_count <= 3: min_fill_ratio = 0.70 elif data_col_count <= 5: min_fill_ratio = 0.76 elif data_col_count <= 8: min_fill_ratio = 0.84 elif data_col_count <= 12: min_fill_ratio = 0.91 else: min_fill_ratio = 0.96 target_table_w = int(round(natural_table_w * 1.06)) # Leave room to avoid over-compression. table_w = min(avail_w, max(int(round(avail_w * min_fill_ratio)), target_table_w)) table_w = max(1, table_w) table_left = left + max(0, (avail_w - table_w) // 2) left_w = [int(table_w * r) for r in left_ratios] data_w = max(1, table_w - sum(left_w)) weights = [1.0 for _ in range(data_col_count)] if spec.delta_col is not None: idx = spec.delta_col - spec.left_cols if 0 <= idx < len(weights): pad = max(2, font_size // 6) pm_size = max(8, int(round(font_size * delta_pm_scale))) gap_pm = max(2, pm_size // 6) kerning = max(1, pm_size // 12) font_pm = ImageFont.truetype(fpath, pm_size) if fpath else font max_w = 0 for c in spec.cells: if c.col != spec.delta_col: continue txt = c.text or "" if c.kind == "data" and "±" in txt: main_text, pm_text = txt.split("±", 1) main_text = main_text.strip() pm_text = "±" + pm_text.strip() tb_main = _measure.textbbox((0, 0), main_text, font=font) main_w = tb_main[2] - tb_main[0] tb_sym = _measure.textbbox((0, 0), "±", font=font_pm) tb_dig = _measure.textbbox((0, 0), pm_text[1:], font=font_pm) sym_w = tb_sym[2] - tb_sym[0] dig_w = tb_dig[2] - tb_dig[0] pm_w = sym_w + dig_w - kerning w = main_w + gap_pm + pm_w + pad * 2 else: tb = _measure.textbbox((0, 0), txt, font=font) w = (tb[2] - tb[0]) + pad * 2 if w > max_w: max_w = w base_col_w = data_w / data_col_count if data_col_count > 0 else data_w need_weight = max_w / max(1.0, base_col_w) delta_fullsize = delta_pm_scale >= 0.98 if data_col_count <= 4: soft_cap = 1.55 if delta_fullsize else 1.35 soft_floor = 1.18 if delta_fullsize else 1.08 elif data_col_count <= 8: soft_cap = 1.72 if delta_fullsize else 1.50 soft_floor = 1.22 if delta_fullsize else 1.10 else: soft_cap = 1.88 if delta_fullsize else 1.65 soft_floor = 1.24 if delta_fullsize else 1.12 widened = max(soft_floor, need_weight) weights[idx] = min(soft_cap, max(1.0, widened)) total_w = sum(weights) col_edges = [table_left] for w in left_w: col_edges.append(col_edges[-1] + w) for i in range(data_col_count): w = int(round(data_w * (weights[i] / total_w))) col_edges.append(col_edges[-1] + w) col_edges[-1] = table_left + table_w section_header_rows = {c.row for c in spec.cells if c.kind == "section"} hidden_header_metric_row: Optional[int] = None if section_header_rows and spec.header_rows >= 2: hidden_header_metric_row = spec.header_rows - 1 weights = [] for r in range(spec.n_rows): if hidden_header_metric_row is not None and r == hidden_header_metric_row: weights.append(0.0) elif r < spec.header_rows: weights.append(1.2) else: weights.append(1.0) total_w = sum(weights) row_edges = [top] for w in weights: row_edges.append(int(round(row_edges[-1] + avail_h * (w / total_w)))) row_edges[-1] = top + avail_h img = Image.new("RGB", (canvas_width, canvas_height), (255, 255, 255)) draw = ImageDraw.Draw(img) def bbox_for(cell: PTCell) -> Tuple[int, int, int, int]: x1 = col_edges[cell.col] x2 = col_edges[cell.col + cell.col_span] y1 = row_edges[cell.row] y2 = row_edges[cell.row + cell.row_span] return (x1, y1, x2, y2) def fit_text_truncate(text: str, max_w: int) -> str: if max_w <= 0: return "" tb = draw.textbbox((0, 0), text, font=font) tw = tb[2] - tb[0] if tw <= max_w: return text lo, hi = 0, len(text) best = "" while lo <= hi: mid = (lo + hi) // 2 cand = text[:mid] w = draw.textbbox((0, 0), cand, font=font)[2] if w <= max_w: best = cand lo = mid + 1 else: hi = mid - 1 return best underline_width = max(1, font_size // 12) bold_offsets = [(0, 0), (1, 0), (0, 1)] if font_size >= 18 else [(0, 0), (1, 0)] def draw_text_marked( xy: Tuple[int, int], text: str, *, font_obj: ImageFont.FreeTypeFont | ImageFont.ImageFont, fill: Tuple[int, int, int], bold: bool, ) -> None: if not bold: draw.text(xy, text, font=font_obj, fill=fill) return x, y = xy for dx, dy in bold_offsets: draw.text((x + dx, y + dy), text, font=font_obj, fill=fill) shade_rows = {c.row for c in spec.cells if c.extra.get("shade_row")} for r in shade_rows: y1 = row_edges[r] y2 = row_edges[r + 1] draw.rectangle((col_edges[0], y1, col_edges[-1], y2), fill=(242, 242, 242)) for cell in spec.cells: bbox = bbox_for(cell) cell.bbox = bbox x1, y1, x2, y2 = bbox if x2 <= x1 or y2 <= y1: continue pad = max(2, font_size // 6) if cell.extra.get("highlight") == "true": try: color = _hex_to_rgb(cell.extra.get("highlight_color", "#FFD2E6")) draw.rectangle(bbox, fill=color) except Exception: pass align = "center" if cell.kind == "group": align = "center" if cell.kind == "item": align = "center" if cell.kind == "data": align = number_align text = cell.text base, cite = _split_citation(text) main_color = (0, 0, 0) cite_color = (30, 102, 204) if cell.kind == "data" and cell.extra.get("text_color") == "true": try: main_color = _hex_to_rgb(str(cell.extra.get("text_color_hex") or "#000000")) except Exception: main_color = (0, 0, 0) if cell.kind == "data": pad = max(2, font_size // 6) gap = max(3, font_size // 5) # Gap between arrow and number, scaled by font size. arrow = cell.extra.get("arrow") base_arrow = max(6, int(round(font_size * float(arrow_scale)))) if arrow in ("up", "down") else 0 max_text_w = (x2 - x1) - 2 * pad - (base_arrow + (gap if base_arrow > 0 else 0)) max_text_w = max(10, max_text_w) text = cell.text delta_mode = bool(cell.extra.get("delta_col")) and "±" in text if delta_mode: main_text, pm_text = text.split("±", 1) main_text = main_text.strip() pm_text = "±" + pm_text.strip() measure_text = main_text else: main_text, pm_text = "", "" measure_text = text tb = draw.textbbox((0, 0), measure_text, font=font) tw = tb[2] - tb[0] th = draw.textbbox((0, 0), "Ag", font=font)[3] s = 1.0 if tw > max_text_w: s = max(0.60, max_text_w / max(1, tw)) # Do not shrink below 60%. if s < 0.999 and fpath and Path(fpath).exists(): font2 = ImageFont.truetype(fpath, max(8, int(round(font_size * s)))) else: font2 = font if delta_mode: tb_main = draw.textbbox((0, 0), main_text, font=font2) tw2 = tb_main[2] - tb_main[0] th2 = draw.textbbox((0, 0), "Ag", font=font2)[3] pm_size = max(8, int(round(font_size * s * delta_pm_scale))) font_pm = ImageFont.truetype(fpath, pm_size) if fpath else font2 pm_symbol = "±" pm_digits = pm_text[1:] if pm_text.startswith("±") else pm_text tb_sym = draw.textbbox((0, 0), pm_symbol, font=font_pm) tb_dig = draw.textbbox((0, 0), pm_digits, font=font_pm) sym_w = tb_sym[2] - tb_sym[0] dig_w = tb_dig[2] - tb_dig[0] pm_h = max(tb_sym[3] - tb_sym[1], tb_dig[3] - tb_dig[1]) kerning = max(1, pm_size // 12) pm_w = sym_w + dig_w - kerning gap_pm = max(2, pm_size // 6) max_text_w2 = max_text_w - (pm_w + gap_pm) if max_text_w2 > 0 and tw > max_text_w2: s = max(0.60, max_text_w2 / max(1, tw)) if s < 0.999 and fpath and Path(fpath).exists(): font2 = ImageFont.truetype(fpath, max(8, int(round(font_size * s)))) else: font2 = font tb_main = draw.textbbox((0, 0), main_text, font=font2) tw2 = tb_main[2] - tb_main[0] th2 = draw.textbbox((0, 0), "Ag", font=font2)[3] pm_size = max(8, int(round(font_size * s * delta_pm_scale))) font_pm = ImageFont.truetype(fpath, pm_size) if fpath else font2 tb_sym = draw.textbbox((0, 0), pm_symbol, font=font_pm) tb_dig = draw.textbbox((0, 0), pm_digits, font=font_pm) sym_w = tb_sym[2] - tb_sym[0] dig_w = tb_dig[2] - tb_dig[0] pm_h = max(tb_sym[3] - tb_sym[1], tb_dig[3] - tb_dig[1]) kerning = max(1, pm_size // 12) pm_w = sym_w + dig_w - kerning gap_pm = max(2, pm_size // 6) else: tb2 = draw.textbbox((0, 0), text, font=font2) tw2 = tb2[2] - tb2[0] th2 = draw.textbbox((0, 0), "Ag", font=font2)[3] usable_right = x2 - pad - (base_arrow + (gap if base_arrow > 0 else 0)) if delta_mode: usable_right -= (pm_w + gap_pm) usable_left = x1 + pad if number_align == "left": tx = usable_left elif number_align == "right": tx = usable_right - tw2 else: tx = usable_left + (usable_right - usable_left - tw2) // 2 ty = y1 + (y2 - y1 - th2) // 2 if delta_mode: gap_pm = max(2, pm_size // 6) pm_x = tx + tw2 + gap_pm pm_y = ty + th2 - pm_h - max(1, pm_size // 3) pm_y = max(y1 + pad, pm_y) if pm_x + pm_w > (x2 - pad): shift = (pm_x + pm_w) - (x2 - pad) tx = max(x1 + pad, tx - shift) pm_x = tx + tw2 + gap_pm is_bold = cell.extra.get("bold") == "true" draw_text_marked((tx, ty), main_text, font_obj=font2, fill=main_color, bold=is_bold) draw_text_marked((pm_x, pm_y), pm_symbol, font_obj=font_pm, fill=main_color, bold=is_bold) draw_text_marked((pm_x + sym_w - kerning, pm_y), pm_digits, font_obj=font_pm, fill=main_color, bold=is_bold) else: draw_text_marked( (tx, ty), text, font_obj=font2, fill=main_color, bold=(cell.extra.get("bold") == "true"), ) if cell.extra.get("underline") == "true": underline_y = ty + th2 + max(2, int(round(font_size * s * 0.10))) draw.line((tx, underline_y, tx + tw2, underline_y), fill=(0, 0, 0), width=underline_width) if arrow in ("up", "down"): size = max(5, int(round(base_arrow * s))) half = size // 2 ax = tx + tw2 + gap ax = min(ax, x2 - pad - size) cy = (y1 + y2) // 2 head_h = max(4, int(round(size * 0.60))) shaft_len = max(4, int(round(size * 1.00))) thickness = max(1, int(round(2 * s))) if arrow == "up": tip = (ax + half, cy - shaft_len // 2 - head_h) base_y = tip[1] + head_h draw.polygon([tip, (ax, base_y), (ax + size, base_y)], fill=main_color) draw.line((ax + half, base_y, ax + half, base_y + shaft_len), fill=main_color, width=thickness) else: tip = (ax + half, cy + shaft_len // 2 + head_h) base_y = tip[1] - head_h draw.polygon([tip, (ax, base_y), (ax + size, base_y)], fill=main_color) draw.line((ax + half, base_y - shaft_len, ax + half, base_y), fill=main_color, width=thickness) continue text_font = font_check if ("✓" in text or "✗" in text or cell.extra.get("is_flag")) else font max_text_w = (x2 - x1) - 2 * pad max_text_w = max(10, max_text_w) if cite: base_fit = fit_text_truncate(base, max_text_w) tb1 = draw.textbbox((0, 0), base_fit, font=font) tb2 = draw.textbbox((0, 0), cite, font=font) tw = (tb1[2] - tb1[0]) + 4 + (tb2[2] - tb2[0]) if tw > max_text_w: base_fit = fit_text_truncate(base, max_text_w - (tb2[2] - tb2[0]) - 4) tb1 = draw.textbbox((0, 0), base_fit, font=font) tw = (tb1[2] - tb1[0]) + 4 + (tb2[2] - tb2[0]) if tw > max_text_w: cite = "" base = base_fit if cite: tb1 = draw.textbbox((0, 0), base, font=font) tb2 = draw.textbbox((0, 0), cite, font=font) tw = (tb1[2] - tb1[0]) + 4 + (tb2[2] - tb2[0]) else: text_fit = fit_text_truncate(text, max_text_w) tb = draw.textbbox((0, 0), text_fit, font=text_font) tw = tb[2] - tb[0] text = text_fit th = draw.textbbox((0, 0), "Ag", font=text_font)[3] if align == "left": tx = x1 + pad elif align == "right": tx = x2 - pad - tw else: tx = x1 + (x2 - x1 - tw) // 2 ty = y1 + (y2 - y1 - th) // 2 if cite: draw_text_marked( (tx, ty), base, font_obj=font, fill=main_color, bold=(cell.extra.get("bold") == "true"), ) tb1 = draw.textbbox((0, 0), base, font=font) bx = tx + (tb1[2] - tb1[0]) + 4 draw_text_marked( (bx, ty), cite, font_obj=font, fill=cite_color, bold=(cell.extra.get("bold") == "true"), ) else: draw_text_marked( (tx, ty), text, font_obj=text_font, fill=main_color, bold=(cell.extra.get("bold") == "true"), ) def _draw_hline(y: int, x1: int, x2: int, w: int = 1, color: Tuple[int, int, int] = (50, 50, 50)) -> None: draw.rectangle((x1, y, x2, y + w - 1), fill=color) def _draw_vline(x: int, y1: int, y2: int, w: int = 1, color: Tuple[int, int, int] = (50, 50, 50)) -> None: draw.rectangle((x, y1, x + w - 1, y2), fill=color) if line_style == "grid": for y in row_edges: _draw_hline(y, col_edges[0], col_edges[-1], 1) for i, x in enumerate(col_edges): if i == 0 or i == len(col_edges) - 1: continue _draw_vline(x, row_edges[0], row_edges[-1], 1) elif line_style == "sparse-grid": top_y = row_edges[0] header_y = row_edges[spec.top_levels] bottom_y = row_edges[-1] left_x = col_edges[0] right_x = col_edges[-1] _draw_hline(top_y, left_x, right_x, 1) _draw_hline(bottom_y, left_x, right_x, 1) _draw_hline(header_y, left_x, right_x, 1) for i in range(1, spec.left_cols + 1): x = col_edges[i] _draw_vline(x, top_y, bottom_y, 1, (60, 60, 60)) if block_sep and spec.n_cols > spec.left_cols: data_start = spec.left_cols last_block = None for i, colinfo in enumerate(spec.data_cols): if colinfo["block"] != last_block: x = col_edges[data_start + i] _draw_vline(x, top_y, bottom_y, 1, (80, 80, 80)) last_block = colinfo["block"] elif line_style == "three-line": top_y = row_edges[0] header_y = row_edges[spec.header_rows] bottom_y = row_edges[-1] _draw_hline(top_y, col_edges[0], col_edges[-1], 2, (30, 30, 30)) _draw_hline(header_y, col_edges[0], col_edges[-1], 2, (30, 30, 30)) _draw_hline(bottom_y, col_edges[0], col_edges[-1], 2, (30, 30, 30)) if block_sep and spec.n_cols > spec.left_cols: data_start = spec.left_cols last_block = None for i, colinfo in enumerate(spec.data_cols): if colinfo["block"] != last_block: x = col_edges[data_start + i] _draw_vline(x, top_y, bottom_y, 1, (80, 80, 80)) last_block = colinfo["block"] if line_style != "none" and section_header_rows: left_x = col_edges[0] right_x = col_edges[-1] for r in sorted(section_header_rows): y_top = row_edges[r] y_bottom = row_edges[r + 1] if y_bottom <= y_top: continue _draw_hline(y_top, left_x, right_x, 1, (55, 55, 55)) _draw_hline(y_bottom, left_x, right_x, 1, (55, 55, 55)) if crop_to_table: pad = max(0, int(crop_pad)) tx1 = max(0, col_edges[0] - pad) ty1 = max(0, row_edges[0] - pad) tx2 = min(img.width, col_edges[-1] + pad + 1) ty2 = min(img.height, row_edges[-1] + pad + 1) if tx2 > tx1 and ty2 > ty1: img = img.crop((tx1, ty1, tx2, ty2)) for c in spec.cells: if c.bbox is None: continue x1, y1, x2, y2 = c.bbox c.bbox = (x1 - tx1, y1 - ty1, x2 - tx1, y2 - ty1) out_path.parent.mkdir(parents=True, exist_ok=True) img.save(str(out_path)) def _spec_layout_is_readable( spec: TableSpec, *, canvas_width: int, canvas_height: int, margins: Tuple[int, int, int, int], font_path: Optional[str], font_size: int, arrow_scale: float, ) -> bool: """Heuristic readability guard: reject layouts that are too dense for the canvas/font. Goal: prevent visibly cramped tables where row heights are too small or numeric text would need excessive shrinking (which can cause overlap / illegibility). """ left, top, right, bottom = margins avail_w = int(canvas_width) - left - right avail_h = int(canvas_height) - top - bottom if avail_w <= 0 or avail_h <= 0: return False if spec.n_rows <= 0 or spec.n_cols <= 0: return False # Approximate row heights (same rule as render_table). row_weights = [1.2 if r < spec.header_rows else 1.0 for r in range(spec.n_rows)] total_row_w = sum(row_weights) or 1.0 row_edges = [top] for w in row_weights: row_edges.append(int(round(row_edges[-1] + avail_h * (w / total_row_w)))) row_edges[-1] = top + avail_h row_heights = [max(0, row_edges[i + 1] - row_edges[i]) for i in range(spec.n_rows)] if not row_heights: return False # Measure text height with actual font. fpath = font_path or _auto_font_path() if fpath and Path(fpath).exists(): font_obj = ImageFont.truetype(fpath, font_size) else: font_obj = ImageFont.load_default() measure = ImageDraw.Draw(Image.new("RGB", (10, 10))) text_h = measure.textbbox((0, 0), "Ag", font=font_obj)[3] min_row_needed = text_h + max(2, font_size // 8) if min(row_heights) < min_row_needed: return False # Approximate data-column widths (same base logic as render_table, simplified). if spec.left_cols == 2: left_ratios = [0.14, 0.22] else: left_ratios = [0.22] left_w = [int(avail_w * r) for r in left_ratios] data_w = max(1, avail_w - sum(left_w)) data_col_count = max(1, (spec.n_cols - spec.left_cols)) col_weights = [1.0 for _ in range(data_col_count)] if spec.delta_col is not None: idx = spec.delta_col - spec.left_cols if 0 <= idx < len(col_weights): # Delta column is widened in render_table; keep a conservative bump here too. col_weights[idx] = max(col_weights[idx], 1.85) total_col_w = sum(col_weights) or 1.0 data_col_widths = [int(round(data_w * (w / total_col_w))) for w in col_weights] if data_col_widths: # Fix rounding drift to preserve total width. data_col_widths[-1] += (data_w - sum(data_col_widths)) min_data_col_w = min(data_col_widths) if data_col_widths else data_w # Estimate whether a typical numeric cell can fit without over-shrinking. pad = max(2, font_size // 6) gap = max(3, font_size // 5) base_arrow = max(6, int(round(font_size * float(arrow_scale)))) sample_num = "88.88" sample_w_bbox = measure.textbbox((0, 0), sample_num, font=font_obj) sample_num_w = max(1, sample_w_bbox[2] - sample_w_bbox[0]) max_text_space = min_data_col_w - 2 * pad - (base_arrow + gap) # Require at least ~75% scale for a typical number; lower than this tends to look cramped. if max_text_space < int(round(sample_num_w * 0.75)): return False return True # ========================= # ========================= _QA_PLACEHOLDER_RE = re.compile(r"\{[A-Z0-9_]+\}") _DG_TOKEN_RE = re.compile(r"\bDG\b") _DG_DEF_CANON = "The numeric part of the table includes numeric cells only; exclude all headers/section headers and left header columns." _DG_DEF_PLAIN = ( "Row/col indices refer to the numeric part of the table only; exclude all headers/section headers and left header columns." ) def _load_question_library(path: Optional[str]) -> Optional[Dict[str, Any]]: if not path: return None p = Path(path) if not p.exists(): return None try: data = json.loads(p.read_text(encoding="utf-8")) except Exception: return None index: Dict[str, Dict[str, Any]] = {} for t in data.get("tasks", []): name = t.get("task_name") if name: index[name] = t for alias in t.get("aliases_old") or []: index[str(alias)] = t return {"data": data, "index": index} def _qa_task_entry(qa_lib: Optional[Dict[str, Any]], task_id: str) -> Optional[Dict[str, Any]]: if not qa_lib: return None return qa_lib.get("index", {}).get(task_id) def _qa_attach_task_metadata(item: Dict[str, Any], qa_lib: Optional[Dict[str, Any]]) -> Dict[str, Any]: """Attach canonical template/category metadata from question.json (if available).""" task_id = str(item.get("task_id") or "") task_entry = _qa_task_entry(qa_lib, task_id) if not task_entry: return item if "qa_task_name" not in item and task_entry.get("task_name"): item["qa_task_name"] = task_entry.get("task_name") if "qa_category" not in item and task_entry.get("category"): item["qa_category"] = task_entry.get("category") if "qa_category_id" not in item and task_entry.get("category_id") is not None: item["qa_category_id"] = task_entry.get("category_id") return item def _qa_requirements_ok( task_entry: Optional[Dict[str, Any]], facts: Dict[str, bool], extra: Optional[Dict[str, Any]] = None, ) -> bool: if not task_entry: return True reqs = task_entry.get("requirements") or [] if not reqs: return True extra = extra or {} for r in reqs: if r == "has_highlight" and not facts.get("has_highlight"): return False if r == "has_underline" and not facts.get("has_underline"): return False if r == "has_bold" and not facts.get("has_bold"): return False if r == "has_text_color" and not facts.get("has_text_color"): return False if r == "has_highlight_or_underline" and not facts.get("has_highlight_or_underline"): return False if r == "has_styled_marker" and not facts.get("has_styled_marker"): return False if r == "has_delta_col" and not facts.get("has_delta_col"): return False if r == "has_group" and not facts.get("has_group"): return False if r == "has_missing" and not facts.get("has_missing"): return False if r == "has_metric_arrow" and not facts.get("has_metric_arrow"): return False if r == "palette_list" and not facts.get("palette_list"): return False if r == "unique_anchor_value" and not extra.get("unique_anchor_value", False): return False if r == "anchor_is_highlighted" and not extra.get("anchor_is_highlighted", False): return False if r == "anchor_is_styled" and not extra.get("anchor_is_styled", False): return False if r == "avoid_ties_in_row" and not extra.get("avoid_ties_in_row", False): return False if r == "avoid_ties_in_col" and not extra.get("avoid_ties_in_col", False): return False if r == "unique_compare" and not extra.get("unique_compare", False): return False if r == "k_le_num_values" and not extra.get("k_le_num_values", False): return False return True def _qa_render_template( template: str, slots: Dict[str, Any], rules: Optional[Dict[str, str]] = None, ) -> str: text = template merged: Dict[str, Any] = {} if rules: merged.update(rules) merged.update(slots) for k, v in merged.items(): text = text.replace("{" + str(k) + "}", str(v)) # Use plain definition rather than the canonical form when no abbreviation precedes it if _DG_DEF_CANON in text: prefix = text.split(_DG_DEF_CANON, 1)[0] if not _DG_TOKEN_RE.search(prefix): text = text.replace(_DG_DEF_CANON, _DG_DEF_PLAIN) text = _QA_PLACEHOLDER_RE.sub("", text) text = " ".join(text.split()) return text def generate_qa( spec: TableSpec, rng: random.Random, *, include_cell_lookup: bool, cell_lookup_samples: int, include_position: bool, position_samples: int, include_col_extremes: bool, col_extremes_k: int, include_row_extremes: bool, row_extremes_k: int, include_col_argmax_item: bool, include_col_argmax_coord: bool, include_topk: bool, topk_k: int, topk_cols: int, include_kth: bool, kth_k: int, include_compare_rows: bool, include_compare_cols: bool, compare_samples: int, include_col_best: bool, include_group_col_best: bool, include_highlight_neighbor: bool, highlight_neighbor_samples: int, include_neighbors_idx: bool, include_neighbors_noidx: bool, neighbor_samples: int, include_color_values: bool, palette_id: str, palette_colors: List[str], palette_names: Optional[Dict[str, str]], include_same_color: bool, same_color_samples: int, include_same_color_noidx: bool, same_color_noidx_samples: int, include_text_color_values: bool, include_underline_values: bool, include_underline_per_col: bool, include_underline_yesno_idx: bool, include_underline_yesno_noidx: bool, underline_yesno_samples: int, include_bold_values: bool, include_bold_per_col: bool, include_bold_yesno_idx: bool, include_bold_yesno_noidx: bool, bold_yesno_samples: int, include_color_yesno_idx: bool, include_color_yesno_noidx: bool, color_yesno_samples: int, include_missing_list: bool, include_missing_check: bool, missing_samples: int, include_count_highlight: bool, include_count_underline: bool, include_count_bold: bool, include_filter_threshold: bool, include_filter_highlight_threshold: bool, filter_samples: int, include_agg_mean_group: bool, include_delta_positive_list: bool, include_argmax_overall: bool, include_multi_hop_style_agg: bool, include_multi_hop_exclude_agg: bool, multi_hop_samples: int, include_counterfactual: bool, include_delta_values: bool, include_delta_best_row: bool, delta_samples: int, qa_lib: Optional[Dict[str, Any]] = None, ) -> List[Dict]: out: List[Dict] = [] data_cells = [c for c in spec.cells if c.kind == "data"] all_data_cells = list(data_cells) by_row: Dict[int, List[PTCell]] = {} by_col: Dict[int, List[PTCell]] = {} for c in data_cells: by_row.setdefault(c.row, []).append(c) by_col.setdefault(c.col, []).append(c) def is_numeric_cell(c: PTCell) -> bool: return c.value is not None and c.text not in ("—", "N/A") data_rows_sorted = sorted({c.row for c in data_cells}) row_idx_map = {r: i + 1 for i, r in enumerate(data_rows_sorted)} row_item_map: Dict[int, str] = {} row_group_map: Dict[int, str] = {} for c in spec.cells: if c.kind == "item": row_item_map[c.row] = c.text if c.kind == "group": for rr in range(c.row, c.row + max(1, c.row_span)): row_group_map[rr] = c.text group_col_name = "Group" if spec.left_cols >= 2: header_cands = [c for c in spec.cells if c.kind == "header" and c.col == 0] if header_cands: header_cands = sorted(header_cands, key=lambda x: (x.row, x.col)) group_col_name = str(header_cands[0].text or "Group") def group_value_for_question(group_name: str) -> str: raw = str(group_name or "").strip() prefix = str(group_col_name or "").strip() if not raw: return raw if prefix: raw_low = raw.lower() prefix_low = prefix.lower() if raw_low == prefix_low: return raw pref_sp = prefix + " " if raw_low.startswith(pref_sp.lower()): tail = raw[len(pref_sp):].strip() if tail: return tail return raw missing_tokens = {"N/A", "—", "-", "–"} has_missing = any( c.kind == "data" and isinstance(c.text, str) and c.text.strip() in missing_tokens for c in spec.cells ) has_metric_arrow = any( ("↑" in str(ci.get("metric", ""))) or ("↓" in str(ci.get("metric", ""))) for ci in spec.data_cols ) has_highlight = any(c.extra.get("highlight") == "true" for c in spec.cells if c.kind == "data") has_underline = any(c.extra.get("underline") == "true" for c in spec.cells if c.kind == "data") has_bold = any(c.extra.get("bold") == "true" for c in spec.cells if c.kind == "data") has_text_color = any(c.extra.get("text_color") == "true" for c in spec.cells if c.kind == "data") has_group = bool(row_group_map) has_styled_marker = has_highlight or has_underline or has_bold or has_text_color facts = { "has_highlight": has_highlight, "has_underline": has_underline, "has_bold": has_bold, "has_text_color": has_text_color, "has_highlight_or_underline": has_styled_marker, "has_styled_marker": has_styled_marker, "has_delta_col": spec.delta_col is not None, "palette_list": bool(palette_colors), "has_group": has_group, "has_missing": has_missing, "has_metric_arrow": has_metric_arrow, } def _ordinal(n: int) -> str: n_abs = abs(int(n)) if 10 <= (n_abs % 100) <= 20: suffix = "th" else: suffix = {1: "st", 2: "nd", 3: "rd"}.get(n_abs % 10, "th") return f"{n}{suffix}" def _normalize_question_surface(task_id: str, text: str) -> str: t = str(text or "") if not t: return t t = t.replace("{{", "{").replace("}}", "}") t = re.sub(r"\b(\d+)-th\b", lambda m: _ordinal(int(m.group(1))), t) pair_obj = '{"item":"...","value":"..."}' t = t.replace('Return JSON {"item":...,"value":...}.', f'Return JSON {pair_obj}.') t = t.replace("Return {item,value}.", f"Return JSON {pair_obj}.") t = t.replace("Output {item,value}.", f"Return JSON {pair_obj}.") t = t.replace("as {item,value}.", f"as JSON {pair_obj}.") t = t.replace("JSON array of pairs", f'JSON array of {pair_obj} objects') t = t.replace("JSON array of {item,value}", f'JSON array of {pair_obj} objects') t = t.replace( "Return JSON with highlighted/color/hex.", 'Return JSON {"highlighted":true/false,"color":,"hex":}.', ) t = t.replace( "Return JSON highlighted/color/hex.", 'Return JSON {"highlighted":true/false,"color":,"hex":}.', ) t = t.replace( "Use ↑/↓ (↑ better, ↓ better if smaller).", "The arrow in the metric name indicates optimization direction: ↑ means higher is better, ↓ means lower is better.", ) t = t.replace( "Take the highlighted numbers highlighted (any color)", "Take all highlighted numbers (any color)", ) t = re.sub( r"row label\s+in\s+the\s+Item\s+column", "main row label in the left header", t, flags=re.IGNORECASE, ) t = re.sub( r"best-performing item\s*\(row label\)", "best-performing item (main row label in the left header)", t, flags=re.IGNORECASE, ) if task_id == "P_NEI_VAL" and "appears exactly once in the numeric part of the table" not in t: t += " The target value appears exactly once in the numeric part of the table." if task_id in {"P_COLOR_YN_VAL", "P_BOLD_YN_VAL", "P_UNDERLINE_YN_VAL"} and "appears exactly once in the numeric data grid" not in t: t += " The value appears exactly once in the numeric data grid." return " ".join(t.split()) def build_question(task_id: str, slots: Dict[str, Any], fallback: str) -> str: entry = _qa_task_entry(qa_lib, task_id) if not entry: return _normalize_question_surface(task_id, fallback) templates = entry.get("question_templates") or [] if not templates: return _normalize_question_surface(task_id, fallback) template = rng.choice(templates) rules = entry.get("rules") or {} q = _qa_render_template(template, slots, rules) return _normalize_question_surface(task_id, q or fallback) def _balanced_binary_sample( positives: List[PTCell], negatives: List[PTCell], k: int, *, strict: bool = False, ) -> List[PTCell]: """Sample binary-labeled items with balanced positive/negative coverage. When ``strict=True`` and both classes exist, prefer an exact 1:1 split (may return fewer than ``k`` items). If one side is absent, fall back to the available side. """ k = max(0, int(k)) if k <= 0: return [] total = len(positives) + len(negatives) if total <= 0: return [] n = min(k, total) if not positives: return rng.sample(negatives, k=min(n, len(negatives))) if not negatives: return rng.sample(positives, k=min(n, len(positives))) if strict: n = min(n, 2 * min(len(positives), len(negatives))) if n <= 0: return [] if n % 2 == 1: n -= 1 if n <= 0: return [] take_pos = n // 2 take_neg = n // 2 picked: List[PTCell] = [] picked.extend(rng.sample(positives, k=take_pos)) picked.extend(rng.sample(negatives, k=take_neg)) rng.shuffle(picked) return picked target_pos = n // 2 + (1 if (n % 2 == 1 and rng.random() < 0.5) else 0) target_neg = n - target_pos take_pos = min(len(positives), target_pos) take_neg = min(len(negatives), target_neg) remain = n - take_pos - take_neg if remain > 0: extra_pos = max(0, len(positives) - take_pos) add_pos = min(remain, extra_pos) take_pos += add_pos remain -= add_pos if remain > 0: extra_neg = max(0, len(negatives) - take_neg) add_neg = min(remain, extra_neg) take_neg += add_neg remain -= add_neg picked: List[PTCell] = [] if take_pos > 0: picked.extend(rng.sample(positives, k=take_pos)) if take_neg > 0: picked.extend(rng.sample(negatives, k=take_neg)) rng.shuffle(picked) return picked def data_col_idx(col: int) -> int: return col - spec.left_cols + 1 def data_row_idx(row: int) -> int: return row_idx_map.get(row, row - spec.data_row_start + 1) def col_name_by_index(col_idx: int) -> str: if 0 <= col_idx < len(spec.data_cols): colinfo = spec.data_cols[col_idx] name = str(colinfo.get("metric", f"Col-{col_idx+1}")) if spec.top_levels >= 2: block = str(colinfo.get("block", "")).strip() mid = str(colinfo.get("mid", "")).strip() if spec.top_levels == 2 and block: return f"{name} (block {block})" if spec.top_levels >= 3: if block and mid: return f"{name} (group {block}/{mid})" if block: return f"{name} (group {block})" return name return f"Col-{col_idx+1}" def _metric_text_by_index(col_idx: int) -> str: if 0 <= col_idx < len(spec.data_cols): return str(spec.data_cols[col_idx].get("metric", "")) return "" def _col_name_by_index_no_arrows(col_idx: int) -> str: """Question-facing column name with arrow glyphs removed (for arrow-aware tasks).""" name = col_name_by_index(col_idx) return re.sub(r"[↑↓▲▼△▽↗↘⇧⇩↟↡]", "", name) def _has_arrow_in_cols(*col_indices: int) -> bool: for ci in col_indices: metric_text = _metric_text_by_index(ci) if ("↑" in metric_text) or ("↓" in metric_text): return True return False def _arrow_rule_for_cols(*col_indices: int) -> str: for ci in col_indices: metric_text = _metric_text_by_index(ci) if ("↑" in metric_text) or ("↓" in metric_text): return "Treat ↑/↓ in the metric name as direction annotations only; compare raw numeric values (do not interpret them as better/worse)." return "" def sample_cols(k: int) -> List[int]: cols = list(range(len(spec.data_cols))) if k > 0 and len(cols) > k: return rng.sample(cols, k=k) return cols if include_position: numeric_cells = [c for c in data_cells if is_numeric_cell(c)] if position_samples > 0 and len(numeric_cells) > position_samples: picked = rng.sample(numeric_cells, k=position_samples) else: picked = list(numeric_cells) for c in sorted(picked, key=lambda x: (x.row, x.col)): row_idx = data_row_idx(c.row) col_idx = data_col_idx(c.col) fallback = ( f"What is the number at row {row_idx}, column {col_idx}? " "Row/column indices refer to the data grid only (exclude header rows and any section header rows; " "columns exclude left header columns). " "Output only the number as a string. Example: \"12.34\"." ) slots = {"R": row_idx, "C": col_idx} q = build_question("P_POS", slots, fallback) out.append( { "task_id": "P_POS", "question": q, "answer": c.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"row": c.row, "col": c.col}, } ) if include_cell_lookup: numeric_cells = [c for c in data_cells if is_numeric_cell(c)] k = max(0, int(cell_lookup_samples)) if numeric_cells and k > 0: for c in rng.sample(numeric_cells, k=min(k, len(numeric_cells))): row_name = row_item_map.get(c.row) col_idx = c.col - spec.left_cols col_name = col_name_by_index(col_idx) if not row_name: continue if not _qa_requirements_ok(_qa_task_entry(qa_lib, "cell_lookup"), facts, {}): continue fallback = ( f"For item {row_name}, what is the value in column {col_name}? " "Exclude N/A and —. Output only the number as a string. Example: \"12.34\"." ) slots = {"ROW_NAME": row_name, "COL_NAME": col_name} q = build_question("cell_lookup", slots, fallback) out.append( { "task_id": "cell_lookup", "question": q, "answer": c.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"row": c.row, "col": c.col}, } ) if include_col_extremes: col_indices = sample_cols(col_extremes_k) for col_idx in col_indices: if _has_arrow_in_cols(col_idx): continue colinfo = spec.data_cols[col_idx] col = spec.left_cols + col_idx vals = [c for c in by_col.get(col, []) if is_numeric_cell(c)] if not vals: continue vmax = max(vals, key=lambda x: x.value) # type: ignore[arg-type] vmin = min(vals, key=lambda x: x.value) # type: ignore[arg-type] max_val = vmax.value min_val = vmin.value unique_max = sum(1 for v in vals if v.value == max_val) == 1 unique_min = sum(1 for v in vals if v.value == min_val) == 1 if spec.top_levels == 3: fallback_max = ( f"What is the maximum value in column {colinfo['metric']} " f"(group {colinfo['block']} / {colinfo.get('mid','')})? Exclude N/A and —. " "Output only the number as a string. Example: \"12.34\"." ) fallback_min = ( f"What is the minimum value in column {colinfo['metric']} " f"(group {colinfo['block']} / {colinfo.get('mid','')})? Exclude N/A and —. " "Output only the number as a string. Example: \"12.34\"." ) elif spec.top_levels == 2: fallback_max = ( f"What is the maximum value in column {colinfo['metric']} (block {colinfo['block']})? Exclude N/A and —. " "Output only the number as a string. Example: \"12.34\"." ) fallback_min = ( f"What is the minimum value in column {colinfo['metric']} (block {colinfo['block']})? Exclude N/A and —. " "Output only the number as a string. Example: \"12.34\"." ) else: fallback_max = f"What is the maximum value in column {colinfo['metric']}? Exclude N/A and —. Output only the number as a string. Example: \"12.34\"." fallback_min = f"What is the minimum value in column {colinfo['metric']}? Exclude N/A and —. Output only the number as a string. Example: \"12.34\"." slots = {"COL_NAME": colinfo["metric"], "ARROW_RULE": _arrow_rule_for_cols(col_idx)} if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_COL_MAX"), facts, {"avoid_ties_in_col": unique_max}): qmax = build_question("P_COL_MAX", slots, fallback_max) out.append( { "task_id": "P_COL_MAX", "question": qmax, "answer": vmax.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"col": col}, } ) if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_COL_MIN"), facts, {"avoid_ties_in_col": unique_min}): qmin = build_question("P_COL_MIN", slots, fallback_min) out.append( { "task_id": "P_COL_MIN", "question": qmin, "answer": vmin.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"col": col}, } ) if include_col_argmax_item or include_col_argmax_coord: col_indices = sample_cols(col_extremes_k) for col_idx in col_indices: if _has_arrow_in_cols(col_idx): continue colinfo = spec.data_cols[col_idx] col = spec.left_cols + col_idx vals = [c for c in by_col.get(col, []) if is_numeric_cell(c)] if not vals: continue vmax = max(vals, key=lambda x: x.value) # type: ignore[arg-type] max_val = vmax.value unique_max = sum(1 for v in vals if v.value == max_val) == 1 row_name = row_item_map.get(vmax.row) if not row_name: continue col_name = col_name_by_index(col_idx) if include_col_argmax_item and _qa_requirements_ok( _qa_task_entry(qa_lib, "col_argmax_item"), facts, {"avoid_ties_in_col": unique_max} ): fallback = ( f"In column {col_name}, which item has the maximum value? " "Return JSON {\"item\":...,\"value\":...}. Exclude N/A and —." ) slots = {"COL_NAME": col_name, "ARROW_RULE": _arrow_rule_for_cols(col_idx)} q = build_question("col_argmax_item", slots, fallback) out.append( { "task_id": "col_argmax_item", "question": q, "answer": {"item": row_name, "value": vmax.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["item", "value"]}, "meta": {"row": vmax.row, "col": vmax.col}, } ) if include_col_argmax_coord and _qa_requirements_ok( _qa_task_entry(qa_lib, "col_argmax_coord"), facts, {"avoid_ties_in_col": unique_max} ): row_idx = data_row_idx(vmax.row) col_idx2 = data_col_idx(vmax.col) fallback = ( f"Find the location (row,col) and value of the maximum cell in column {col_name}. " "Output JSON {\"row\":,\"col\":,\"value\":}. " "Row/col refer to the data grid only (exclude headers/section headers; left header columns excluded). " "Exclude N/A and —." ) slots = {"COL_NAME": col_name, "ARROW_RULE": _arrow_rule_for_cols(col_idx)} q = build_question("col_argmax_coord", slots, fallback) out.append( { "task_id": "col_argmax_coord", "question": q, "answer": {"row": row_idx, "col": col_idx2, "value": vmax.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["row", "col", "value"]}, "meta": {"row": vmax.row, "col": vmax.col}, } ) # 2.6) Top-K / K-th if include_topk or include_kth: col_indices = sample_cols(topk_cols) for col_idx in col_indices: if _has_arrow_in_cols(col_idx): continue col = spec.left_cols + col_idx col_name = col_name_by_index(col_idx) vals = [c for c in by_col.get(col, []) if is_numeric_cell(c)] if not vals: continue uniq = len({c.value for c in vals}) == len(vals) if include_topk and _qa_requirements_ok( _qa_task_entry(qa_lib, "topk_by_metric"), facts, {"avoid_ties_in_col": uniq, "k_le_num_values": len(vals) >= max(1, int(topk_k))} ): k = max(1, int(topk_k)) if len(vals) >= k: vals_sorted = sorted(vals, key=lambda x: x.value, reverse=True) # type: ignore[arg-type] top_vals = vals_sorted[:k] pairs = [] for c in top_vals: item = row_item_map.get(c.row) if not item: continue pairs.append({"item": item, "value": c.text}) if pairs: fallback = ( f"List the top-{k} items by column {col_name}. " "Return a JSON array of {item,value}. Exclude N/A and —." ) slots = {"COL_NAME": col_name, "K": k, "ARROW_RULE": _arrow_rule_for_cols(col_idx)} q = build_question("topk_by_metric", slots, fallback) out.append( { "task_id": "topk_by_metric", "question": q, "answer": pairs, "answer_type": "list", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"col": col}, } ) if include_kth and _qa_requirements_ok( _qa_task_entry(qa_lib, "kth_rank_by_metric"), facts, {"avoid_ties_in_col": uniq, "k_le_num_values": len(vals) >= max(1, int(kth_k))} ): k = max(1, int(kth_k)) if len(vals) >= k: vals_sorted = sorted(vals, key=lambda x: x.value, reverse=True) # type: ignore[arg-type] c = vals_sorted[k - 1] item = row_item_map.get(c.row) if item: fallback = ( f"Who ranks {k}-th in column {col_name}? " "Return JSON {\"item\":...,\"value\":...}. Exclude N/A and —." ) slots = {"COL_NAME": col_name, "K": k, "ARROW_RULE": _arrow_rule_for_cols(col_idx)} q = build_question("kth_rank_by_metric", slots, fallback) out.append( { "task_id": "kth_rank_by_metric", "question": q, "answer": {"item": item, "value": c.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["item", "value"]}, "meta": {"row": c.row, "col": c.col}, } ) if include_row_extremes: rows = list(by_row.keys()) if row_extremes_k > 0 and len(rows) > row_extremes_k: rows = rng.sample(rows, k=row_extremes_k) for row in rows: vals = by_row.get(row, []) vals = [c for c in vals if is_numeric_cell(c)] if not vals: continue vmax = max(vals, key=lambda x: x.value) # type: ignore[arg-type] vmin = min(vals, key=lambda x: x.value) # type: ignore[arg-type] max_val = vmax.value min_val = vmin.value unique_max = sum(1 for v in vals if v.value == max_val) == 1 unique_min = sum(1 for v in vals if v.value == min_val) == 1 item_cell = next((c for c in spec.cells if c.kind == "item" and c.row == row), None) item_name = item_cell.text if item_cell else f"row {row}" fallback_max = ( f"For item {item_name}, what is the maximum value across all metrics? Exclude N/A and —. " "Output only the number as a string. Example: \"12.34\"." ) fallback_min = ( f"For item {item_name}, what is the minimum value across all metrics? Exclude N/A and —. " "Output only the number as a string. Example: \"12.34\"." ) slots = {"ROW_NAME": item_name} if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_ROW_MAX"), facts, {"avoid_ties_in_row": unique_max}): qmax = build_question("P_ROW_MAX", slots, fallback_max) out.append( { "task_id": "P_ROW_MAX", "question": qmax, "answer": vmax.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"row": row}, } ) if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_ROW_MIN"), facts, {"avoid_ties_in_row": unique_min}): qmin = build_question("P_ROW_MIN", slots, fallback_min) out.append( { "task_id": "P_ROW_MIN", "question": qmin, "answer": vmin.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"row": row}, } ) if include_compare_rows or include_compare_cols: numeric_cells = [c for c in data_cells if is_numeric_cell(c)] if numeric_cells: rows = sorted({c.row for c in numeric_cells}) cols = list(range(len(spec.data_cols))) k = max(0, int(compare_samples)) if include_compare_rows and k > 0: for _ in range(k): if len(rows) < 2 or not cols: break r1, r2 = rng.sample(rows, 2) col_idx = rng.choice(cols) col = spec.left_cols + col_idx c1 = next((c for c in by_row.get(r1, []) if c.col == col and is_numeric_cell(c)), None) c2 = next((c for c in by_row.get(r2, []) if c.col == col and is_numeric_cell(c)), None) if not c1 or not c2: continue if c1.value == c2.value: continue row_a = row_item_map.get(r1) row_b = row_item_map.get(r2) if not row_a or not row_b: continue winner = c1 if (c1.value or 0) > (c2.value or 0) else c2 winner_name = row_item_map.get(winner.row) if not winner_name: continue col_name = col_name_by_index(col_idx) if _has_arrow_in_cols(col_idx): continue if not _qa_requirements_ok(_qa_task_entry(qa_lib, "compare_two_systems_one_metric"), facts, {"unique_compare": True}): continue fallback = ( f"Compare {row_a} vs {row_b} on {col_name}. Which one is larger? " "Return JSON {\"item\":...,\"value\":...}. Exclude N/A and —." ) slots = { "ROW_NAME_A": row_a, "ROW_NAME_B": row_b, "COL_NAME": col_name, "ARROW_RULE": _arrow_rule_for_cols(col_idx), } q = build_question("compare_two_systems_one_metric", slots, fallback) out.append( { "task_id": "compare_two_systems_one_metric", "question": q, "answer": {"item": winner_name, "value": winner.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["item", "value"]}, "meta": {"row": winner.row, "col": winner.col}, } ) if include_compare_cols and k > 0: for _ in range(k): if len(rows) < 1 or len(cols) < 2: break r = rng.choice(rows) col_idx_a, col_idx_b = rng.sample(cols, 2) col_a = spec.left_cols + col_idx_a col_b = spec.left_cols + col_idx_b c1 = next((c for c in by_row.get(r, []) if c.col == col_a and is_numeric_cell(c)), None) c2 = next((c for c in by_row.get(r, []) if c.col == col_b and is_numeric_cell(c)), None) if not c1 or not c2: continue if c1.value == c2.value: continue row_name = row_item_map.get(r) if not row_name: continue col_name_a = col_name_by_index(col_idx_a) col_name_b = col_name_by_index(col_idx_b) if _has_arrow_in_cols(col_idx_a, col_idx_b): continue winner = c1 if (c1.value or 0) > (c2.value or 0) else c2 winner_col = col_name_a if winner is c1 else col_name_b if not _qa_requirements_ok(_qa_task_entry(qa_lib, "compare_two_metrics_one_system"), facts, {"unique_compare": True}): continue fallback = ( f"For {row_name}, compare {col_name_a} and {col_name_b}. " "Which metric value is larger? Return JSON {\"item\":,\"value\":}. " "Exclude N/A and —." ) slots = { "ROW_NAME": row_name, "COL_NAME_A": col_name_a, "COL_NAME_B": col_name_b, "ARROW_RULE": _arrow_rule_for_cols(col_idx_a, col_idx_b), } q = build_question("compare_two_metrics_one_system", slots, fallback) out.append( { "task_id": "compare_two_metrics_one_system", "question": q, "answer": {"item": winner_col, "value": winner.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["item", "value"]}, "meta": {"row": r, "col": winner.col}, } ) if include_col_best: col_indices = sample_cols(col_extremes_k) for col_idx in col_indices: col = spec.left_cols + col_idx vals = [c for c in by_col.get(col, []) if is_numeric_cell(c)] if not vals: continue metric = col_name_by_index(col_idx) metric_q = _col_name_by_index_no_arrows(col_idx) if "↓" in metric: best = min(vals, key=lambda x: x.value) # type: ignore[arg-type] direction = "↓" else: best = max(vals, key=lambda x: x.value) # type: ignore[arg-type] direction = "↑" item = row_item_map.get(best.row) if not item: continue if not _qa_requirements_ok(_qa_task_entry(qa_lib, "col_best_system_by_arrow"), facts, {}): continue fallback = ( f"For column {metric_q}, which item is the best? " "Return JSON {\"item\":...,\"value\":...}. Exclude N/A and —." ) slots = {"COL_NAME": metric_q, "DIR": direction} q = build_question("col_best_system_by_arrow", slots, fallback) out.append( { "task_id": "col_best_system_by_arrow", "question": q, "answer": {"item": item, "value": best.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["item", "value"]}, "meta": {"row": best.row, "col": best.col}, } ) if include_group_col_best and row_group_map: groups = sorted(set(row_group_map.values())) col_indices = sample_cols(col_extremes_k) for _ in range(max(1, min(len(groups), len(col_indices)))): group_name = rng.choice(groups) col_idx = rng.choice(col_indices) if col_indices else 0 col = spec.left_cols + col_idx metric = col_name_by_index(col_idx) metric_q = _col_name_by_index_no_arrows(col_idx) group_rows = [r for r, g in row_group_map.items() if g == group_name] vals = [c for c in data_cells if c.row in group_rows and c.col == col and is_numeric_cell(c)] if not vals: continue if "↓" in metric: best = min(vals, key=lambda x: x.value) # type: ignore[arg-type] else: best = max(vals, key=lambda x: x.value) # type: ignore[arg-type] item = row_item_map.get(best.row) if not item: continue if not _qa_requirements_ok(_qa_task_entry(qa_lib, "group_col_best"), facts, {}): continue group_value = group_value_for_question(group_name) fallback = ( f'Inside "{group_name}", which item is best on {metric_q}? ' "Return JSON {\"item\":...,\"value\":...}. Exclude N/A and —." ) slots = { "GROUP_NAME": group_name, "GROUP_COL_NAME": group_col_name, "GROUP_VALUE": group_value, "COL_NAME": metric_q, } q = build_question("group_col_best", slots, fallback) out.append( { "task_id": "group_col_best", "question": q, "answer": {"item": item, "value": best.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["item", "value"]}, "meta": {"row": best.row, "col": best.col, "group": group_name, "group_col_name": group_col_name, "group_value": group_value}, } ) if include_neighbors_idx or include_neighbors_noidx: cell_map: Dict[Tuple[int, int], PTCell] = {(c.row, c.col): c for c in spec.cells} def neighbor_value(row: int, col: int) -> Optional[str]: c = cell_map.get((row, col)) if not c or c.kind != "data": return None if c.text in ("N/A", "—"): return c.text if c.value is None: return None return c.text def has_full_neighbors(c: PTCell) -> bool: return all( neighbor_value(c.row + dr, c.col + dc) is not None for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)] ) highlighted = [c for c in data_cells if c.extra.get("highlight") == "true" and c.value is not None and has_full_neighbors(c)] non_highlighted = [c for c in data_cells if c.extra.get("highlight") != "true" and c.value is not None and has_full_neighbors(c)] value_count: Dict[str, int] = {} for c in data_cells: value_count[c.text] = value_count.get(c.text, 0) + 1 def add_neighbor_q_idx(c: PTCell) -> None: row_idx = row_idx_map.get(c.row, c.row - spec.data_row_start + 1) col_idx = c.col - spec.left_cols + 1 fallback = ( f"At (r={row_idx},c={col_idx}) in the numeric part of the table, return the target and its four neighbors " "(up, down, left, right) as JSON " "{\"target\":\"12.34\",\"up\":\"..\",\"down\":\"..\",\"left\":\"..\",\"right\":\"..\"}. " "The numeric part of the table includes numeric/data cells only (no headers). " "If a neighbor cell contains N/A or —, return that token string." ) slots = {"R": row_idx, "C": col_idx} if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_NEI_IDX"), facts, {}): return q = build_question("P_NEI_IDX", slots, fallback) ans = { "target": c.text, "up": neighbor_value(c.row - 1, c.col), "down": neighbor_value(c.row + 1, c.col), "left": neighbor_value(c.row, c.col - 1), "right": neighbor_value(c.row, c.col + 1), } out.append( { "task_id": "P_NEI_IDX", "question": q, "answer": ans, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["target", "up", "down", "left", "right"]}, "meta": {"row": c.row, "col": c.col}, } ) def add_neighbor_q_noidx(c: PTCell) -> None: fallback = ( f"At the cell with value {c.text}, return the target and its four neighbors " "(up, down, left, right) as JSON " "{\"target\":\"12.34\",\"up\":\"..\",\"down\":\"..\",\"left\":\"..\",\"right\":\"..\"}. " "The numeric part of the table includes numeric/data cells only (no headers). " "If a neighbor cell contains N/A or —, return that token string." ) if not _qa_requirements_ok( _qa_task_entry(qa_lib, "P_NEI_VAL"), facts, {"unique_anchor_value": True}, ): return slots = {"ANCHOR_VAL": c.text} q = build_question("P_NEI_VAL", slots, fallback) ans = { "target": c.text, "up": neighbor_value(c.row - 1, c.col), "down": neighbor_value(c.row + 1, c.col), "left": neighbor_value(c.row, c.col - 1), "right": neighbor_value(c.row, c.col + 1), } out.append( { "task_id": "P_NEI_VAL", "question": q, "answer": ans, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["target", "up", "down", "left", "right"]}, "meta": {"row": c.row, "col": c.col}, } ) k = max(0, int(neighbor_samples)) if include_neighbors_idx and k > 0: pool = highlighted + non_highlighted if pool: for c in rng.sample(pool, k=min(k, len(pool))): add_neighbor_q_idx(c) if include_neighbors_noidx and k > 0: pool_noidx = [c for c in highlighted + non_highlighted if value_count.get(c.text, 0) == 1] if pool_noidx: for c in rng.sample(pool_noidx, k=min(k, len(pool_noidx))): add_neighbor_q_noidx(c) if include_highlight_neighbor: cell_map: Dict[Tuple[int, int], PTCell] = {(c.row, c.col): c for c in spec.cells} name_map = _build_palette_color_names(palette_colors, explicit=palette_names) text_color_hexes = sorted( { str(c.extra.get("text_color_hex") or "").upper() for c in all_data_cells if c.extra.get("text_color") == "true" and str(c.extra.get("text_color_hex") or "").strip() } ) text_name_map = _build_palette_color_names(text_color_hexes) if text_color_hexes else {} styled_cells = [ c for c in all_data_cells if c.extra.get("highlight") == "true" or c.extra.get("underline") == "true" or c.extra.get("bold") == "true" or c.extra.get("text_color") == "true" ] dirs = [("left", (0, -1)), ("right", (0, 1)), ("up", (-1, 0)), ("down", (1, 0))] k = max(0, int(highlight_neighbor_samples)) if k > 0 and styled_cells: for c in rng.sample(styled_cells, k=min(k, len(styled_cells))): rng.shuffle(dirs) chosen = None for dname, (dr, dc) in dirs: nb = cell_map.get((c.row + dr, c.col + dc)) if not nb or nb.kind != "data": continue if not is_numeric_cell(nb): continue chosen = (dname, nb) break if not chosen: continue dname, nb = chosen style_candidates: List[Tuple[str, List[PTCell]]] = [] if c.extra.get("underline") == "true": matched = [x for x in all_data_cells if x.extra.get("underline") == "true"] style_candidates.append(("underlined", matched)) if c.extra.get("bold") == "true": matched = [x for x in all_data_cells if x.extra.get("bold") == "true"] style_candidates.append(("boldfaced", matched)) if c.extra.get("highlight") == "true": color_hex = (c.extra.get("highlight_color") or "").upper() matched = [ x for x in all_data_cells if x.extra.get("highlight") == "true" and (x.extra.get("highlight_color") or "").upper() == color_hex ] color_name = name_map.get(color_hex, "color") if color_hex: style_candidates.append((f"highlighted in {color_name} (hex {color_hex})", matched)) else: style_candidates.append(("highlighted", matched)) if c.extra.get("text_color") == "true": t_hex = (c.extra.get("text_color_hex") or "").upper() matched = [ x for x in all_data_cells if x.extra.get("text_color") == "true" and (x.extra.get("text_color_hex") or "").upper() == t_hex ] t_name = str(c.extra.get("text_color_name") or text_name_map.get(t_hex, "color")) if t_hex: style_candidates.append((f"text-colored in {t_name} (hex {t_hex})", matched)) else: style_candidates.append(("text-colored", matched)) style_desc_candidates: List[Tuple[str, str]] = [] for base_desc, matched in style_candidates: if not matched: continue if len(matched) == 1 and matched[0] is c: style_desc_candidates.append((base_desc, "")) continue same_val = [x for x in matched if x.text == c.text] if len(same_val) == 1: style_desc_candidates.append((base_desc, f" with value {c.text}")) if not style_desc_candidates: continue style_desc, anchor_clause = rng.choice(style_desc_candidates) if not _qa_requirements_ok( _qa_task_entry(qa_lib, "highlight_neighbor"), facts, {"anchor_is_styled": True}, ): continue fallback = ( f"Locate the {style_desc} number and return the number immediately to its {dname}. " "Neighbor answer is guaranteed to be a numeric value (not N/A/—). " "Output only the number as a string. Example: \"12.34\"." ) slots = {"DIR": dname, "STYLE_DESC": style_desc, "ANCHOR_CLAUSE": anchor_clause} q = build_question("highlight_neighbor", slots, fallback) out.append( { "task_id": "highlight_neighbor", "question": q, "answer": nb.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"row": c.row, "col": c.col}, } ) if include_color_values: color_map: Dict[str, List[str]] = {} for c in data_cells: if c.extra.get("highlight") == "true": color = (c.extra.get("highlight_color") or "").upper() if not color: continue color_map.setdefault(color, []).append(c.text) name_map = _build_palette_color_names(palette_colors, explicit=palette_names) for color_hex, vals in color_map.items(): color_name = name_map.get(color_hex, "color") if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_COLOR"), facts, {}): continue fallback = ( f"List numbers highlighted in {color_name} (hex {color_hex}). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) slots = {"COLOR_NAME": color_name, "COLOR_HEX": color_hex} q = build_question("P_COLOR", slots, fallback) out.append( { "task_id": "P_COLOR", "question": q, "answer": vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": { "color": color_hex, "color_name": color_name, "palette_id": palette_id, }, } ) if include_same_color: name_map = _build_palette_color_names(palette_colors, explicit=palette_names) highlighted = [c for c in data_cells if c.extra.get("highlight") == "true" and c.value is not None] k = max(0, int(same_color_samples)) if k > 0 and highlighted: for c in rng.sample(highlighted, k=min(k, len(highlighted))): row_idx = row_idx_map.get(c.row, c.row - spec.data_row_start + 1) col_idx = c.col - spec.left_cols + 1 color_hex = (c.extra.get("highlight_color") or "").upper() color_name = name_map.get(color_hex, "color") same_vals = [ x.text for x in data_cells if x.extra.get("highlight") == "true" and (x.extra.get("highlight_color") or "").upper() == color_hex ] if not _qa_requirements_ok( _qa_task_entry(qa_lib, "P_SAME_COLOR"), facts, {"anchor_is_highlighted": True}, ): continue fallback = ( f"For the number at row {row_idx}, column {col_idx} (value {c.text}), " f"list all numbers highlighted with the same color ({color_name}, hex {color_hex}). " "Row/column indices refer to the data grid only (exclude header rows and any section header rows; " "columns exclude left header columns). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) slots = {"R": row_idx, "C": col_idx, "COLOR_NAME": color_name, "COLOR_HEX": color_hex} q = build_question("P_SAME_COLOR", slots, fallback) out.append( { "task_id": "P_SAME_COLOR", "question": q, "answer": same_vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": { "row": c.row, "col": c.col, "color": color_hex, "color_name": color_name, }, } ) if include_text_color_values: text_color_map: Dict[str, List[str]] = {} for c in data_cells: if c.extra.get("text_color") == "true": color_hex = (c.extra.get("text_color_hex") or "").upper() if not color_hex: continue text_color_map.setdefault(color_hex, []).append(c.text) if text_color_map: text_color_hexes = sorted(text_color_map.keys()) text_name_map = _build_palette_color_names(text_color_hexes) for color_hex, vals in text_color_map.items(): if not vals: continue color_name = text_name_map.get(color_hex, "color") if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_TEXT_COLOR"), facts, {}): continue fallback = ( f"List numbers whose text is colored in {color_name} (hex {color_hex}). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) slots = {"COLOR_NAME": color_name, "COLOR_HEX": color_hex} q = build_question("P_TEXT_COLOR", slots, fallback) out.append( { "task_id": "P_TEXT_COLOR", "question": q, "answer": vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"color": color_hex, "color_name": color_name, "marker_type": "text_color"}, } ) if include_same_color_noidx: name_map = _build_palette_color_names(palette_colors, explicit=palette_names) highlighted = [c for c in data_cells if c.extra.get("highlight") == "true" and c.value is not None] value_count = {} for c in highlighted: value_count[c.text] = value_count.get(c.text, 0) + 1 pool = [c for c in highlighted if value_count.get(c.text, 0) == 1] k = max(0, int(same_color_noidx_samples)) if k > 0 and pool: for c in rng.sample(pool, k=min(k, len(pool))): color_hex = (c.extra.get("highlight_color") or "").upper() color_name = name_map.get(color_hex, "color") same_vals = [ x.text for x in data_cells if x.extra.get("highlight") == "true" and (x.extra.get("highlight_color") or "").upper() == color_hex ] if not _qa_requirements_ok( _qa_task_entry(qa_lib, "P_SAME_COLOR_VAL"), facts, {"unique_anchor_value": True, "anchor_is_highlighted": True}, ): continue fallback = ( f"For the number with value {c.text}, list all numbers highlighted with the same color " f"({color_name}, hex {color_hex}). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) slots = {"ANCHOR_VAL": c.text, "COLOR_NAME": color_name, "COLOR_HEX": color_hex} q = build_question("P_SAME_COLOR_VAL", slots, fallback) out.append( { "task_id": "P_SAME_COLOR_VAL", "question": q, "answer": same_vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"color": color_hex, "color_name": color_name}, } ) underlined_cells = [c for c in data_cells if c.extra.get("underline") == "true"] if include_underline_values and underlined_cells: if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_UNDERLINE"), facts, {}): underlined = [c.text for c in underlined_cells] fallback = ( "List all underlined numbers. Output only a JSON array of strings. " "Example: [\"12.34\",\"56.78\"]." ) q = build_question("P_UNDERLINE", {}, fallback) out.append( { "task_id": "P_UNDERLINE", "question": q, "answer": underlined, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {}, } ) bold_cells = [c for c in data_cells if c.extra.get("bold") == "true"] if include_bold_values and bold_cells: if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_BOLD"), facts, {}): bold_vals = [c.text for c in bold_cells] fallback = ( "List all bold numbers. Output only a JSON array of strings. " "Example: [\"12.34\",\"56.78\"]." ) q = build_question("P_BOLD", {}, fallback) out.append( { "task_id": "P_BOLD", "question": q, "answer": bold_vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {}, } ) if include_underline_per_col and underlined_cells: by_col_under: Dict[int, List[str]] = {} seen_underline_col_q: set[str] = set() for c in underlined_cells: by_col_under.setdefault(c.col, []).append(c.text) for col_idx, colinfo in enumerate(spec.data_cols): col = spec.left_cols + col_idx vals = by_col_under.get(col, []) if not vals: continue if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_UNDERLINE_COL"), facts, {}): continue if spec.top_levels == 3: fallback = ( f"List all underlined numbers in column {colinfo['metric']} " f"(group {colinfo['block']} / {colinfo.get('mid','')}). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) elif spec.top_levels == 2: fallback = ( f"List all underlined numbers in column {colinfo['metric']} (block {colinfo['block']}). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) else: fallback = ( f"List all underlined numbers in column {colinfo['metric']}. " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) slots = {"COL_NAME": col_name_by_index(col_idx)} q = build_question("P_UNDERLINE_COL", slots, fallback) if q in seen_underline_col_q: continue seen_underline_col_q.add(q) out.append( { "task_id": "P_UNDERLINE_COL", "question": q, "answer": vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"col": col}, } ) if include_bold_per_col and bold_cells: by_col_bold: Dict[int, List[str]] = {} seen_bold_col_q: set[str] = set() for c in bold_cells: by_col_bold.setdefault(c.col, []).append(c.text) for col_idx, colinfo in enumerate(spec.data_cols): col = spec.left_cols + col_idx vals = by_col_bold.get(col, []) if not vals: continue if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_BOLD_COL"), facts, {}): continue if spec.top_levels == 3: fallback = ( f"List all bold numbers in column {colinfo['metric']} " f"(group {colinfo['block']} / {colinfo.get('mid','')}). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) elif spec.top_levels == 2: fallback = ( f"List all bold numbers in column {colinfo['metric']} (block {colinfo['block']}). " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) else: fallback = ( f"List all bold numbers in column {colinfo['metric']}. " "Output only a JSON array of strings. Example: [\"12.34\",\"56.78\"]." ) slots = {"COL_NAME": col_name_by_index(col_idx)} q = build_question("P_BOLD_COL", slots, fallback) if q in seen_bold_col_q: continue seen_bold_col_q.add(q) out.append( { "task_id": "P_BOLD_COL", "question": q, "answer": vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"col": col}, } ) if include_count_highlight and has_highlight: if _qa_requirements_ok(_qa_task_entry(qa_lib, "count_highlighted_cells"), facts, {}): count_hl = sum(1 for c in all_data_cells if c.extra.get("highlight") == "true") fallback = 'How many highlighted cells are in the table? Output only the count as a string. Example: "7".' q = build_question("count_highlighted_cells", {}, fallback) out.append( { "task_id": "count_highlighted_cells", "question": q, "answer": str(count_hl), "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {}, } ) if include_count_underline and has_underline: if _qa_requirements_ok(_qa_task_entry(qa_lib, "count_underlined_cells"), facts, {}): count_ul = sum(1 for c in all_data_cells if c.extra.get("underline") == "true") fallback = 'How many underlined numbers are in the table? Output only the count as a string. Example: "5".' q = build_question("count_underlined_cells", {}, fallback) out.append( { "task_id": "count_underlined_cells", "question": q, "answer": str(count_ul), "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {}, } ) if include_count_bold and has_bold: if _qa_requirements_ok(_qa_task_entry(qa_lib, "count_bold_cells"), facts, {}): count_b = sum(1 for c in all_data_cells if c.extra.get("bold") == "true") fallback = 'How many bold numbers are in the table? Output only the count as a string. Example: "4".' q = build_question("count_bold_cells", {}, fallback) out.append( { "task_id": "count_bold_cells", "question": q, "answer": str(count_b), "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {}, } ) if include_missing_list and has_missing: by_col_missing: Dict[int, List[str]] = {} for c in data_cells: if isinstance(c.text, str) and c.text.strip() in missing_tokens: name = row_item_map.get(c.row) if not name: continue by_col_missing.setdefault(c.col, []).append(name) if by_col_missing and _qa_requirements_ok(_qa_task_entry(qa_lib, "missing_list_in_column"), facts, {}): cols = list(by_col_missing.keys()) if missing_samples > 0 and len(cols) > missing_samples: cols = rng.sample(cols, k=missing_samples) for col in cols: col_idx = col - spec.left_cols col_name = col_name_by_index(col_idx) rows = by_col_missing.get(col, []) if not rows: continue fallback = ( f"In {col_name}, which rows have missing values (N/A or —)? " "Return a JSON array of row names. Example: [\"System-A\",\"System-B\"]." ) slots = {"COL_NAME": col_name} q = build_question("missing_list_in_column", slots, fallback) out.append( { "task_id": "missing_list_in_column", "question": q, "answer": rows, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"col": col}, } ) if include_missing_check and has_missing: if _qa_requirements_ok(_qa_task_entry(qa_lib, "missing_check_cell"), facts, {}): pool = [c for c in data_cells if c.kind == "data"] k = max(0, int(missing_samples)) if pool and k > 0: pool_missing = [ c for c in pool if isinstance(c.text, str) and c.text.strip() in missing_tokens ] pool_not_missing = [ c for c in pool if not (isinstance(c.text, str) and c.text.strip() in missing_tokens) ] for c in _balanced_binary_sample(pool_missing, pool_not_missing, k, strict=True): row_name = row_item_map.get(c.row) col_name = col_name_by_index(c.col - spec.left_cols) if not row_name: continue is_missing = isinstance(c.text, str) and c.text.strip() in missing_tokens fallback = ( f"Is the cell ({row_name}, {col_name}) missing (N/A or —)? " "Answer JSON {\"missing\":true/false}." ) slots = {"ROW_NAME": row_name, "COL_NAME": col_name} q = build_question("missing_check_cell", slots, fallback) out.append( { "task_id": "missing_check_cell", "question": q, "answer": {"missing": bool(is_missing)}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["missing"]}, "meta": {"row": c.row, "col": c.col}, } ) if include_filter_threshold: if _qa_requirements_ok(_qa_task_entry(qa_lib, "filter_values_by_threshold"), facts, {}): cols = sample_cols(filter_samples if filter_samples > 0 else 1) for col_idx in cols: col = spec.left_cols + col_idx col_name = col_name_by_index(col_idx) vals = [c for c in by_col.get(col, []) if is_numeric_cell(c)] if len(vals) < 2: continue vals_sorted = sorted(vals, key=lambda x: x.value) # type: ignore[arg-type] pivot = vals_sorted[len(vals_sorted) // 2] op = rng.choice([">", ">=", "<", "<="]) thr = float(pivot.value or 0.0) if op == ">": matched = [c for c in vals if (c.value or 0) > thr] elif op == ">=": matched = [c for c in vals if (c.value or 0) >= thr] elif op == "<": matched = [c for c in vals if (c.value or 0) < thr] else: matched = [c for c in vals if (c.value or 0) <= thr] if not matched: continue pairs = [] for c in matched: item = row_item_map.get(c.row) if not item: continue pairs.append({"item": item, "value": c.text}) if not pairs: continue fallback = ( f"In column {col_name}, list all items with value {op} {thr:.2f}. " "Return JSON array of {item,value}. Exclude N/A and —." ) slots = {"COL_NAME": col_name, "OP": op, "THRESH": f"{thr:.2f}"} q = build_question("filter_values_by_threshold", slots, fallback) out.append( { "task_id": "filter_values_by_threshold", "question": q, "answer": pairs, "answer_type": "list", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"col": col}, } ) if include_filter_highlight_threshold and has_highlight: if _qa_requirements_ok(_qa_task_entry(qa_lib, "filter_highlighted_values_by_threshold"), facts, {}): hl_vals = [c for c in all_data_cells if c.extra.get("highlight") == "true" and is_numeric_cell(c)] if len(hl_vals) >= 2: vals_sorted = sorted(hl_vals, key=lambda x: x.value) # type: ignore[arg-type] pivot = vals_sorted[len(vals_sorted) // 2] op = rng.choice([">", ">=", "<", "<="]) thr = float(pivot.value or 0.0) if op == ">": matched = [c.text for c in hl_vals if (c.value or 0) > thr] elif op == ">=": matched = [c.text for c in hl_vals if (c.value or 0) >= thr] elif op == "<": matched = [c.text for c in hl_vals if (c.value or 0) < thr] else: matched = [c.text for c in hl_vals if (c.value or 0) <= thr] if matched: fallback = ( f"Among highlighted cells, list the values that are {op} {thr:.2f}. " "Output JSON array of strings." ) slots = {"OP": op, "THRESH": f"{thr:.2f}", "COLOR_DESC": "(any color)"} q = build_question("filter_highlighted_values_by_threshold", slots, fallback) out.append( { "task_id": "filter_highlighted_values_by_threshold", "question": q, "answer": matched, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {}, } ) if include_agg_mean_group and has_group: if _qa_requirements_ok(_qa_task_entry(qa_lib, "aggregate_mean_metric_in_group"), facts, {}): groups = sorted(set(row_group_map.values())) if groups: group_name = rng.choice(groups) col_indices = sample_cols(1) if col_indices: col_idx = col_indices[0] col = spec.left_cols + col_idx col_name = col_name_by_index(col_idx) rows = [r for r, g in row_group_map.items() if g == group_name] vals = [c for c in data_cells if c.row in rows and c.col == col and is_numeric_cell(c)] if vals: mean = sum(c.value for c in vals if c.value is not None) / len(vals) group_value = group_value_for_question(group_name) fallback = ( f'Within "{group_name}", what is the mean value of column {col_name}? ' "Exclude N/A and —. Output only the number as a string. Example: \"12.34\"." ) slots = { "GROUP_NAME": group_name, "GROUP_COL_NAME": group_col_name, "GROUP_VALUE": group_value, "COL_NAME": col_name, } q = build_question("aggregate_mean_metric_in_group", slots, fallback) out.append( { "task_id": "aggregate_mean_metric_in_group", "question": q, "answer": f"{mean:.2f}", "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"group": group_name, "group_col_name": group_col_name, "group_value": group_value, "col": col}, } ) if include_color_yesno_idx or include_color_yesno_noidx: palette_upper = [c.upper() for c in palette_colors] name_map = _build_palette_color_names(palette_colors, explicit=palette_names) color_list = [f"{name_map.get(h, 'color')}({h})" for h in palette_upper] color_list_str = ", ".join(color_list) highlighted = [c for c in data_cells if c.extra.get("highlight") == "true" and c.value is not None] non_highlighted = [c for c in data_cells if c.extra.get("highlight") != "true" and c.value is not None] pool = highlighted + non_highlighted k = max(0, int(color_yesno_samples)) value_count: Dict[str, int] = {} for c in pool: value_count[c.text] = value_count.get(c.text, 0) + 1 if include_color_yesno_idx and k > 0 and pool: for c in _balanced_binary_sample(highlighted, non_highlighted, k, strict=True): row_idx = row_idx_map.get(c.row, c.row - spec.data_row_start + 1) col_idx = c.col - spec.left_cols + 1 is_hl = c.extra.get("highlight") == "true" color_hex = (c.extra.get("highlight_color") or "").upper() color_name = name_map.get(color_hex, "color") if is_hl else None if not _qa_requirements_ok( _qa_task_entry(qa_lib, "P_COLOR_YN_IDX"), facts, {"unique_anchor_value": True}, ): continue fallback = ( f"In this table, some numbers are highlighted using the following colors: {color_list_str}. " f"Is the number at (r={row_idx},c={col_idx}) highlighted? " "Answer in JSON: {\"highlighted\":true/false,\"color\":,\"hex\":}. " "Example: {\"highlighted\":true,\"color\":\"light_blue\",\"hex\":\"#CFE0FF\"}." ) slots = {"R": row_idx, "C": col_idx, "PALETTE_LIST": color_list_str} q = build_question("P_COLOR_YN_IDX", slots, fallback) ans = { "highlighted": bool(is_hl), "color": color_name if is_hl else None, "hex": color_hex if is_hl else None, } out.append( { "task_id": "P_COLOR_YN_IDX", "question": q, "answer": ans, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["highlighted", "color", "hex"]}, "meta": {"row": c.row, "col": c.col}, } ) if include_color_yesno_noidx and k > 0: pool_noidx = [c for c in pool if value_count.get(c.text, 0) == 1] if pool_noidx: pool_noidx_hl = [c for c in pool_noidx if c.extra.get("highlight") == "true"] pool_noidx_non_hl = [c for c in pool_noidx if c.extra.get("highlight") != "true"] for c in _balanced_binary_sample(pool_noidx_hl, pool_noidx_non_hl, k, strict=True): is_hl = c.extra.get("highlight") == "true" color_hex = (c.extra.get("highlight_color") or "").upper() color_name = name_map.get(color_hex, "color") if is_hl else None if not _qa_requirements_ok( _qa_task_entry(qa_lib, "P_COLOR_YN_VAL"), facts, {"unique_anchor_value": True}, ): continue fallback = ( f"In this table, some numbers are highlighted using the following colors: {color_list_str}. " f"Is the number with value {c.text} highlighted? " "Answer in JSON: {\"highlighted\":true/false,\"color\":,\"hex\":}. " "Example: {\"highlighted\":true,\"color\":\"light_blue\",\"hex\":\"#CFE0FF\"}." ) slots = {"ANCHOR_VAL": c.text, "PALETTE_LIST": color_list_str} q = build_question("P_COLOR_YN_VAL", slots, fallback) ans = { "highlighted": bool(is_hl), "color": color_name if is_hl else None, "hex": color_hex if is_hl else None, } out.append( { "task_id": "P_COLOR_YN_VAL", "question": q, "answer": ans, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["highlighted", "color", "hex"]}, "meta": {"row": c.row, "col": c.col}, } ) if include_underline_yesno_idx or include_underline_yesno_noidx: underline_pos = [c for c in data_cells if c.extra.get("underline") == "true" and c.value is not None] underline_neg = [c for c in data_cells if c.extra.get("underline") != "true" and c.value is not None] pool = underline_pos + underline_neg k_underline = max(0, int(underline_yesno_samples)) value_count_underline: Dict[str, int] = {} for c in pool: value_count_underline[c.text] = value_count_underline.get(c.text, 0) + 1 if include_underline_yesno_idx and k_underline > 0 and pool: for c in _balanced_binary_sample(underline_pos, underline_neg, k_underline, strict=True): row_idx = row_idx_map.get(c.row, c.row - spec.data_row_start + 1) col_idx = c.col - spec.left_cols + 1 is_underlined = c.extra.get("underline") == "true" if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_UNDERLINE_YN_IDX"), facts, {}): continue fallback = ( f"Is the number at (r={row_idx},c={col_idx}) in the numeric part of the table underlined? " "Answer JSON {\"underlined\":true/false}. " "The numeric part of the table includes numeric cells only; exclude all headers/section headers and left header columns. " "Example: {\"underlined\":true}." ) slots = {"R": row_idx, "C": col_idx} q = build_question("P_UNDERLINE_YN_IDX", slots, fallback) out.append( { "task_id": "P_UNDERLINE_YN_IDX", "question": q, "answer": {"underlined": bool(is_underlined)}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["underlined"]}, "meta": {"row": c.row, "col": c.col}, } ) if include_underline_yesno_noidx and k_underline > 0: pool_noidx = [c for c in pool if value_count_underline.get(c.text, 0) == 1] if pool_noidx: pool_noidx_pos = [c for c in pool_noidx if c.extra.get("underline") == "true"] pool_noidx_neg = [c for c in pool_noidx if c.extra.get("underline") != "true"] for c in _balanced_binary_sample(pool_noidx_pos, pool_noidx_neg, k_underline, strict=True): is_underlined = c.extra.get("underline") == "true" if not _qa_requirements_ok( _qa_task_entry(qa_lib, "P_UNDERLINE_YN_VAL"), facts, {"unique_anchor_value": True}, ): continue fallback = ( f"Is the number with value {c.text} underlined? " "Answer JSON {\"underlined\":true/false}. Example: {\"underlined\":false}." ) slots = {"ANCHOR_VAL": c.text} q = build_question("P_UNDERLINE_YN_VAL", slots, fallback) out.append( { "task_id": "P_UNDERLINE_YN_VAL", "question": q, "answer": {"underlined": bool(is_underlined)}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["underlined"]}, "meta": {"row": c.row, "col": c.col}, } ) if include_bold_yesno_idx or include_bold_yesno_noidx: bold_cells = [c for c in data_cells if c.extra.get("bold") == "true" and c.value is not None] non_bold_cells = [c for c in data_cells if c.extra.get("bold") != "true" and c.value is not None] pool = bold_cells + non_bold_cells k_bold = max(0, int(bold_yesno_samples)) value_count_bold: Dict[str, int] = {} for c in pool: value_count_bold[c.text] = value_count_bold.get(c.text, 0) + 1 if include_bold_yesno_idx and k_bold > 0 and pool: for c in _balanced_binary_sample(bold_cells, non_bold_cells, k_bold, strict=True): row_idx = row_idx_map.get(c.row, c.row - spec.data_row_start + 1) col_idx = c.col - spec.left_cols + 1 is_bold = c.extra.get("bold") == "true" if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_BOLD_YN_IDX"), facts, {}): continue fallback = ( f"Is the number at (r={row_idx},c={col_idx}) in the numeric part of the table boldfaced? " "Answer JSON {\"bold\":true/false}. " "The numeric part of the table includes numeric cells only; exclude all headers/section headers and left header columns. " "Example: {\"bold\":true}." ) slots = {"R": row_idx, "C": col_idx} q = build_question("P_BOLD_YN_IDX", slots, fallback) out.append( { "task_id": "P_BOLD_YN_IDX", "question": q, "answer": {"bold": bool(is_bold)}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["bold"]}, "meta": {"row": c.row, "col": c.col}, } ) if include_bold_yesno_noidx and k_bold > 0: pool_noidx = [c for c in pool if value_count_bold.get(c.text, 0) == 1] if pool_noidx: pool_noidx_bold = [c for c in pool_noidx if c.extra.get("bold") == "true"] pool_noidx_non_bold = [c for c in pool_noidx if c.extra.get("bold") != "true"] for c in _balanced_binary_sample(pool_noidx_bold, pool_noidx_non_bold, k_bold, strict=True): is_bold = c.extra.get("bold") == "true" if not _qa_requirements_ok( _qa_task_entry(qa_lib, "P_BOLD_YN_VAL"), facts, {"unique_anchor_value": True}, ): continue fallback = ( f"Is the number with value {c.text} boldfaced? " "Answer JSON {\"bold\":true/false}. Example: {\"bold\":false}." ) slots = {"ANCHOR_VAL": c.text} q = build_question("P_BOLD_YN_VAL", slots, fallback) out.append( { "task_id": "P_BOLD_YN_VAL", "question": q, "answer": {"bold": bool(is_bold)}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["bold"]}, "meta": {"row": c.row, "col": c.col}, } ) if spec.delta_col is not None: delta_idx = spec.delta_col - spec.left_cols if 0 <= delta_idx < len(spec.data_cols): delta_name = spec.data_cols[delta_idx].get("metric", "Δ") else: delta_name = "Δ" delta_cells = [c for c in all_data_cells if c.col == spec.delta_col and c.extra.get("delta_col")] if include_delta_values and delta_cells: vals = [c.text for c in delta_cells] if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_DELTA_COL"), facts, {}): fallback = ( f"List all values in the delta column {delta_name}. " "Output only a JSON array of strings. Example: [\"+1.70 ± 0.29\",\"-0.34 ± 0.24\"]." ) slots = {"COL_NAME": delta_name} q = build_question("P_DELTA_COL", slots, fallback) out.append( { "task_id": "P_DELTA_COL", "question": q, "answer": vals, "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"col": spec.delta_col}, } ) if include_delta_best_row and delta_cells: delta_vals = {c.row: float(c.extra.get("delta_base", -1e9)) for c in delta_cells} best_row = max(delta_vals, key=lambda r: delta_vals[r]) best_val = delta_vals[best_row] unique_best = sum(1 for v in delta_vals.values() if v == best_val) == 1 if _qa_requirements_ok(_qa_task_entry(qa_lib, "P_DELTA_BEST_ROW"), facts, {"avoid_ties_in_col": unique_best}): row_idx = row_idx_map.get(best_row, best_row - spec.data_row_start + 1) fallback = ( f"Which row has the maximum delta in column {delta_name}? " "Return the data-row index as a string. Example: \"4\"." ) slots = {"COL_NAME": delta_name} q = build_question("P_DELTA_BEST_ROW", slots, fallback) out.append( { "task_id": "P_DELTA_BEST_ROW", "question": q, "answer": str(row_idx), "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"row": best_row}, } ) # Row-wise delta value lookup is part of the delta-value family; only emit # it when delta-value questions are explicitly enabled. if include_delta_values and delta_samples > 0 and delta_cells: for c in rng.sample(delta_cells, k=min(delta_samples, len(delta_cells))): row_idx = row_idx_map.get(c.row, c.row - spec.data_row_start + 1) if not _qa_requirements_ok(_qa_task_entry(qa_lib, "P_DELTA_VAL"), facts, {}): continue fallback = ( f"For the delta column {delta_name}, what is the value at row {row_idx}? " "Output the full string. Example: \"+1.70 ± 0.29\"." ) slots = {"COL_NAME": delta_name, "R": row_idx} q = build_question("P_DELTA_VAL", slots, fallback) out.append( { "task_id": "P_DELTA_VAL", "question": q, "answer": c.text, "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {"row": c.row, "col": c.col}, } ) if include_delta_positive_list and spec.delta_col is not None: delta_cells = [c for c in all_data_cells if c.col == spec.delta_col and c.extra.get("delta_col")] if delta_cells and _qa_requirements_ok(_qa_task_entry(qa_lib, "delta_gain_positive_list"), facts, {}): pairs = [] for c in delta_cells: base = float(c.extra.get("delta_base", 0.0)) if base <= 0: continue item = row_item_map.get(c.row) if not item: continue pairs.append({"item": item, "value": c.text}) if pairs: delta_name = None delta_idx = spec.delta_col - spec.left_cols if 0 <= delta_idx < len(spec.data_cols): delta_name = spec.data_cols[delta_idx].get("metric", "Δ") delta_name = delta_name or "Δ" fallback = ( f"In column {delta_name}, list all items whose value is positive (> 0). " "Return JSON array of {item,value}. Exclude N/A and —." ) slots = {"COL_NAME": delta_name} q = build_question("delta_gain_positive_list", slots, fallback) out.append( { "task_id": "delta_gain_positive_list", "question": q, "answer": pairs, "answer_type": "list", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"col": spec.delta_col}, } ) if include_argmax_overall: if facts.get("has_metric_arrow"): pass elif _qa_requirements_ok(_qa_task_entry(qa_lib, "argmax_overall_coord"), facts, {}): vals = [c for c in data_cells if is_numeric_cell(c)] if vals: max_val = max(c.value for c in vals if c.value is not None) cands = [c for c in vals if c.value == max_val] # reading order tie-break: row then col best = sorted(cands, key=lambda x: (x.row, x.col))[0] row_idx = data_row_idx(best.row) col_idx = data_col_idx(best.col) fallback = ( "Find the single largest numeric cell in the entire data grid. " "Return JSON {\"row\":,\"col\":,\"value\":}. " "Row/col refer to data grid only (exclude headers/section headers; exclude left header columns). " "Exclude N/A and —." ) q = build_question("argmax_overall_coord", {}, fallback) out.append( { "task_id": "argmax_overall_coord", "question": q, "answer": {"row": row_idx, "col": col_idx, "value": best.text}, "answer_type": "record", "scoring": {"type": "record_multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_object", "keys": ["row", "col", "value"]}, "meta": {"row": best.row, "col": best.col}, } ) if include_multi_hop_style_agg and facts.get("has_highlight_or_underline"): if _qa_requirements_ok(_qa_task_entry(qa_lib, "multi_hop_style_then_aggregate"), facts, {}): k = max(1, int(multi_hop_samples)) for _ in range(k): style_modes: List[str] = [] if has_highlight: style_modes.append("highlight") if has_underline: style_modes.append("underline") if has_bold: style_modes.append("bold") if has_text_color: style_modes.append("text_color") if not style_modes: continue chosen_style = rng.choice(style_modes) if chosen_style == "underline": style_desc = "underlined" chosen = [c for c in all_data_cells if c.extra.get("underline") == "true" and is_numeric_cell(c)] elif chosen_style == "bold": style_desc = "boldfaced" chosen = [c for c in all_data_cells if c.extra.get("bold") == "true" and is_numeric_cell(c)] elif chosen_style == "text_color": style_desc = "text-colored" chosen = [c for c in all_data_cells if c.extra.get("text_color") == "true" and is_numeric_cell(c)] else: style_desc = "highlighted (any color)" chosen = [c for c in all_data_cells if c.extra.get("highlight") == "true" and is_numeric_cell(c)] if chosen: op = rng.choice(["sum", "mean", "max", "min"]) vals = [c.value for c in chosen if c.value is not None] if vals: if op == "sum": agg = sum(vals) elif op == "mean": agg = sum(vals) / len(vals) elif op == "max": agg = max(vals) else: agg = min(vals) fallback = ( f"Among {style_desc} numbers, compute the {op}. " "Exclude N/A and —. Output only the number as a string. Example: \"12.34\"." ) slots = {"STYLE_DESC": style_desc, "AGG_OP": op} q = build_question("multi_hop_style_then_aggregate", slots, fallback) out.append( { "task_id": "multi_hop_style_then_aggregate", "question": q, "answer": f"{agg:.2f}", "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {}, } ) if include_multi_hop_exclude_agg and facts.get("has_highlight_or_underline"): if _qa_requirements_ok(_qa_task_entry(qa_lib, "multi_hop_exclude_style_then_aggregate"), facts, {}): k = max(1, int(multi_hop_samples)) for _ in range(k): style_modes: List[str] = [] if has_highlight: style_modes.append("highlight") if has_underline: style_modes.append("underline") if has_bold: style_modes.append("bold") if has_text_color: style_modes.append("text_color") if not style_modes: continue chosen_style = rng.choice(style_modes) if chosen_style == "underline": style_desc = "underlined" remain = [c for c in all_data_cells if c.extra.get("underline") != "true" and is_numeric_cell(c)] elif chosen_style == "bold": style_desc = "boldfaced" remain = [c for c in all_data_cells if c.extra.get("bold") != "true" and is_numeric_cell(c)] elif chosen_style == "text_color": style_desc = "text-colored" remain = [c for c in all_data_cells if c.extra.get("text_color") != "true" and is_numeric_cell(c)] else: style_desc = "highlighted (any color)" remain = [c for c in all_data_cells if c.extra.get("highlight") != "true" and is_numeric_cell(c)] if remain: op = rng.choice(["sum", "mean", "max", "min"]) vals = [c.value for c in remain if c.value is not None] if vals: if op == "sum": agg = sum(vals) elif op == "mean": agg = sum(vals) / len(vals) elif op == "max": agg = max(vals) else: agg = min(vals) fallback = ( f"Ignoring {style_desc} cells, compute the {op} over the rest in the whole table. " "Exclude N/A and —. Output only the number as a string. Example: \"12.34\"." ) slots = {"STYLE_DESC": style_desc, "AGG_OP": op, "SCOPE_DESC": "in the whole table"} q = build_question("multi_hop_exclude_style_then_aggregate", slots, fallback) out.append( { "task_id": "multi_hop_exclude_style_then_aggregate", "question": q, "answer": f"{agg:.2f}", "answer_type": "string", "scoring": {"type": "exact"}, "expected_format": {"type": "string"}, "meta": {}, } ) if include_counterfactual: if _qa_requirements_ok(_qa_task_entry(qa_lib, "counterfactual_style_absent"), facts, {}): name_map = _build_palette_color_names(palette_colors, explicit=palette_names) used = {str(c.extra.get("highlight_color") or "").upper() for c in all_data_cells if c.extra.get("highlight") == "true"} palette_upper = [c.upper() for c in palette_colors] candidates = [h for h in palette_upper if h not in used] if not candidates and palette_upper: candidates = [] if candidates: color_hex = rng.choice(candidates) color_name = name_map.get(color_hex, "color") style_desc = f"{color_name} highlight" fallback = ( f"List all numbers highlighted in {color_name} (hex {color_hex}). " "If none, output an empty JSON array []." ) slots = {"COLOR_NAME": color_name, "COLOR_HEX": color_hex, "STYLE_DESC": style_desc} q = build_question("counterfactual_style_absent", slots, fallback) out.append( { "task_id": "counterfactual_style_absent", "question": q, "answer": [], "answer_type": "list", "scoring": {"type": "multiset_exact", "penalty_extra": True}, "expected_format": {"type": "json_array", "order": "any"}, "meta": {"color": color_hex, "color_name": color_name}, } ) if qa_lib: out = [_qa_attach_task_metadata(item, qa_lib) for item in out] return out def _write_clean_qa(in_path: Path, out_path: Path) -> None: keep_order = [ "qid", "image_path", "image_id", "task_id", "qa_task_name", "qa_category", "qa_category_id", "table_shape_profile", "question", "answer", ] if not in_path.exists(): return out_path.parent.mkdir(parents=True, exist_ok=True) with in_path.open("r", encoding="utf-8") as fin, out_path.open("w", encoding="utf-8") as fout: for line in fin: line = line.strip() if not line: continue try: rec = json.loads(line) except Exception: continue out = {k: rec.get(k) for k in keep_order if k in rec} fout.write(json.dumps(out, ensure_ascii=False) + "\n") # ========================= # ========================= def main() -> int: p = argparse.ArgumentParser(description="Generate paper-style result tables (PNG + JSON).") p.add_argument("--out-dir", default="out_paper") p.add_argument("--count", type=int, default=5) p.add_argument("--seed", type=int, default=0) p.add_argument("--canvas-width", type=int, default=1400) p.add_argument("--canvas-height", type=int, default=800) p.add_argument("--margins", default="40,40,40,40", help="left,top,right,bottom") p.add_argument("--crop-to-table", dest="crop_to_table", action="store_true", default=True, help="Crop output image to table bbox with padding.") p.add_argument("--no-crop-to-table", dest="crop_to_table", action="store_false", help="Keep full canvas (no post-render crop).") p.add_argument("--crop-pad", type=int, default=12, help="Padding (pixels) when cropping to table bbox.") p.add_argument("--font-path", default=None) p.add_argument("--font-size", type=int, default=24) p.add_argument("--line-style", choices=["none", "grid", "three-line", "sparse-grid"], default="three-line") p.add_argument("--block-sep", action="store_true", help="Draw vertical separators between blocks.") p.add_argument("--number-align", choices=["left", "center", "right"], default="center") p.add_argument("--arrow-offset-x", type=int, default=0, help="Arrow x offset (pixels).") p.add_argument("--arrow-offset-y", type=int, default=0, help="Arrow y offset (pixels).") p.add_argument("--arrow-scale", type=float, default=0.38, help="Arrow size scale vs font size.") p.add_argument("--delta-pm-scale", type=float, default=1.00, help="Relative font scale for ±std text in delta column (default 1.0, same as main digits).") p.add_argument("--group-count", type=int, default=3) p.add_argument("--min-items", type=int, default=3) p.add_argument("--max-items", type=int, default=5) p.add_argument("--block-count", type=int, default=3) p.add_argument("--min-metrics", type=int, default=2) p.add_argument("--max-metrics", type=int, default=3) p.add_argument("--mid-groups-min", type=int, default=1, help="Min mid-groups per top group when top-levels=3.") p.add_argument("--mid-groups-max", type=int, default=2, help="Max mid-groups per top group when top-levels=3.") p.add_argument("--section-count", type=int, default=0, help="Insert mid-table section header rows.") p.add_argument("--unique-numbers", action="store_true", help="Ensure all numeric cells are unique.") p.add_argument("--top-levels", choices=["1", "2", "3", "random"], default="random", help="Top header levels (1/2/3/random).") p.add_argument("--left-levels", choices=["1", "2", "random"], default="random", help="Left header levels (1/2/random).") p.add_argument( "--table-shape-mode", choices=["fixed", "mixed"], default="fixed", help="fixed = use one structural regime; mixed = per-image sample compact/wide/tall/dense_header profiles.", ) p.add_argument( "--table-shape-profile-probs", default="1,1,1,1", help="Weights for mixed shape profiles: compact,wide,tall,dense_header.", ) p.add_argument("--merge-group-prob", type=float, default=0.7) p.add_argument("--citation-prob", type=float, default=0.3) p.add_argument("--missing-prob", type=float, default=0.05) p.add_argument("--dec-min", type=int, default=2) p.add_argument("--dec-max", type=int, default=2) p.add_argument("--highlight", action="store_true", help="Enable soft-color highlights.") p.add_argument("--highlight-mode", choices=["single", "multi", "random"], default="random") p.add_argument("--highlight-rate", type=float, default=0.12, help="Highlight ratio for data cells.") p.add_argument("--highlight-count", type=int, default=0, help="Fixed highlight count (overrides rate if >0).") p.add_argument( "--highlight-colors", default="#FFD2E6,#E1FFE1,#FFFAD2,#FFB3B3", help="Comma-separated soft colors (<=4 recommended).", ) p.add_argument( "--highlight-palettes", default=None, help="Multiple palettes separated by ';'. Each palette is comma-separated colors.", ) p.add_argument( "--highlight-palettes-file", default=None, help="JSON file with palettes (e.g. palette_preview/index.json).", ) p.add_argument("--highlight-use-all-colors", action="store_true", help="Ensure all colors appear in one image.") p.add_argument("--underline-rate", type=float, default=0.0, help="Underline ratio for data cells.") p.add_argument("--underline-best-per-col", action="store_true", help="Underline best value in each column.") p.add_argument("--underline-second-per-col", action="store_true", help="Underline second-best value in each column.") p.add_argument("--underline-wrong-per-col", action="store_true", help="Underline a non-best value in each column.") p.add_argument("--underline-image-prob", type=float, default=1.0, help="Probability to apply underlines per image.") p.add_argument("--bold-rate", type=float, default=0.0, help="Bold ratio for data cells.") p.add_argument("--bold-best-per-col", action="store_true", help="Bold best value in each column.") p.add_argument("--bold-wrong-per-col", action="store_true", help="Bold a non-best value in each column.") p.add_argument("--bold-image-prob", type=float, default=1.0, help="Probability to apply bold per image.") p.add_argument("--text-color-delta-sign", action="store_true", help="Color delta-column text by sign (pos/neg).") p.add_argument("--text-color-best-per-col", action="store_true", help="Color best value text in each numeric column.") p.add_argument("--text-color-image-prob", type=float, default=0.0, help="Probability to apply text color per image.") p.add_argument("--text-color-pos-hex", default="#2E7D32", help="Text color for positive delta values.") p.add_argument("--text-color-neg-hex", default="#C62828", help="Text color for negative delta values.") p.add_argument("--text-color-best-hex", default="#1565C0", help="Text color for best-per-column values.") p.add_argument( "--marker-combo-mode", choices=["independent", "three-way"], default="independent", help="How to mix underline/bold across images. three-way forces underline_only/bold_only/both (no none).", ) p.add_argument( "--marker-combo-probs", default="1,1,6", help="Weights for three-way marker combo mode: underline_only,bold_only,both.", ) p.add_argument( "--marker-role-policy", choices=["manual", "paper"], default="manual", help="In three-way mode, paper = underline-only=>underline-best, bold-only=>bold-best, both=>bold-best+underline-second.", ) p.add_argument( "--underline-image-prob-overall", type=float, default=0.4, help="Target overall underline ratio (0~1). If set and auto-abc enabled, A-group will be 0 and B/C will be scaled.", ) p.add_argument( "--bold-image-prob-overall", type=float, default=-1.0, help="Target overall bold ratio (0~1). If set and auto-abc enabled, A-group will be 0 and B/C will be scaled.", ) p.add_argument("--arrow-rate", type=float, default=0.0, help="Arrow ratio for data cells.") p.add_argument("--arrow-up-ratio", type=float, default=0.5, help="Fraction of arrows that are up.") p.add_argument("--data-arrows", action="store_true", help="Enable arrows on data cells (disabled by default).") p.add_argument("--metric-arrow-prob", type=float, default=0.6, help="Probability to append ↑/↓ to metric names.") p.add_argument("--config-rows", action="store_true", help="Place a Δ column inside the table (no extra ✓/✗ rows).") p.add_argument( "--config-rows-prob", type=float, default=0.2, help="Probability to enable the Δ column per image (only if --config-rows is set).", ) p.add_argument( "--config-flag-pool", default=None, help="Comma-separated pool for the two config flag names.", ) p.add_argument("--config-shade-best-row", action="store_true", help="Shade the best Δ row lightly.") p.add_argument("--highlight-strategy", choices=["random", "by_column_rank", "by_column_wrong"], default="random") p.add_argument("--highlight-rank-k", type=int, default=0, help="Top-K per column when using by_column_rank.") p.add_argument("--qa-position", action="store_true", help="Ask all position questions.") p.add_argument("--qa-position-samples", type=int, default=5, help="Samples of P_POS per image (0=all).") p.add_argument("--qa-cell-lookup", action="store_true", help="Ask row+col name lookup questions.") p.add_argument("--qa-cell-lookup-samples", type=int, default=5, help="Samples of row+col lookup per image.") p.add_argument("--qa-col-extremes", action="store_true", help="Ask max/min per column.") p.add_argument("--qa-col-extremes-k", type=int, default=5, help="Max number of columns for max/min questions (0=all).") p.add_argument("--qa-row-extremes", action="store_true", help="Ask max/min per row.") p.add_argument("--qa-row-extremes-k", type=int, default=5, help="Max number of rows for max/min questions (0=all).") p.add_argument("--qa-col-argmax-item", action="store_true", help="Ask argmax item per column.") p.add_argument("--qa-col-argmax-coord", action="store_true", help="Ask argmax coord per column.") p.add_argument("--qa-topk", action="store_true", help="Ask top-k per column.") p.add_argument("--qa-topk-k", type=int, default=3, help="K for top-k.") p.add_argument("--qa-topk-cols", type=int, default=3, help="Number of columns for top-k.") p.add_argument("--qa-kth", action="store_true", help="Ask k-th per column.") p.add_argument("--qa-kth-k", type=int, default=2, help="K for k-th.") p.add_argument("--qa-compare-rows", action="store_true", help="Compare two rows on one metric.") p.add_argument("--qa-compare-cols", action="store_true", help="Compare two metrics within one row.") p.add_argument("--qa-compare-samples", type=int, default=3, help="Number of compare questions per image.") p.add_argument("--qa-col-best", action="store_true", help="Ask best item per column using arrow direction.") p.add_argument("--qa-group-col-best", action="store_true", help="Ask best item per group in a column.") p.add_argument("--qa-highlight-neighbor", action="store_true", help="Neighbor of highlighted/underlined/bold cell.") p.add_argument("--qa-highlight-neighbor-samples", type=int, default=3, help="Samples for highlight-neighbor.") p.add_argument("--qa-neighbors-idx", action="store_true", help="Neighbor questions with (row,col).") p.add_argument("--qa-neighbors-noidx", action="store_true", help="Neighbor questions by value only (unique values).") p.add_argument("--qa-neighbor-samples", type=int, default=5, help="Number of neighbor samples per variant per image.") p.add_argument("--qa-color-values", action="store_true", help="Ask for values by highlight color.") p.add_argument("--qa-same-color", action="store_true", help="Ask for values sharing the same highlight color.") p.add_argument("--qa-same-color-samples", type=int, default=5, help="Number of same-color questions per image.") p.add_argument("--qa-same-color-noidx", action="store_true", help="Same-color questions without (row,col).") p.add_argument("--qa-same-color-noidx-samples", type=int, default=5, help="Number of same-color (no idx) questions per image.") p.add_argument("--qa-text-color-values", action="store_true", help="Ask for values by text color (e.g., red text).") p.add_argument("--qa-underline", action="store_true", help="Ask for all underlined numbers.") p.add_argument("--qa-underline-per-col", action="store_true", help="Ask for underlined numbers per column.") p.add_argument("--qa-underline-yesno-idx", action="store_true", help="Underline yes/no questions with (row,col).") p.add_argument("--qa-underline-yesno-noidx", action="store_true", help="Underline yes/no questions by value only (unique values).") p.add_argument("--qa-underline-yesno-samples", type=int, default=5, help="Number of underline yes/no questions per variant per image.") p.add_argument("--qa-bold", action="store_true", help="Ask for all bold numbers.") p.add_argument("--qa-bold-per-col", action="store_true", help="Ask for bold numbers per column.") p.add_argument("--qa-bold-yesno-idx", action="store_true", help="Bold yes/no questions with (row,col).") p.add_argument("--qa-bold-yesno-noidx", action="store_true", help="Bold yes/no questions by value only (unique values).") p.add_argument("--qa-bold-yesno-samples", type=int, default=5, help="Number of bold yes/no questions per variant per image.") p.add_argument("--qa-color-yesno-idx", action="store_true", help="Color yes/no questions with (row,col).") p.add_argument("--qa-color-yesno-noidx", action="store_true", help="Color yes/no questions by value only (unique values).") p.add_argument("--qa-color-yesno-samples", type=int, default=5, help="Number of color yes/no questions per variant per image.") p.add_argument("--qa-missing-list", action="store_true", help="Ask missing list per column.") p.add_argument("--qa-missing-check", action="store_true", help="Ask missing check for a cell.") p.add_argument("--qa-missing-samples", type=int, default=3, help="Samples for missing check/list.") p.add_argument("--qa-count-highlight", action="store_true", help="Count highlighted cells.") p.add_argument("--qa-count-underline", action="store_true", help="Count underlined cells.") p.add_argument("--qa-count-bold", action="store_true", help="Count bold cells.") p.add_argument("--qa-filter-threshold", action="store_true", help="Filter values by threshold.") p.add_argument("--qa-filter-highlight-threshold", action="store_true", help="Filter highlighted values by threshold.") p.add_argument("--qa-filter-samples", type=int, default=3, help="Samples for threshold filter.") p.add_argument("--qa-agg-mean-group", action="store_true", help="Mean in group for one column.") p.add_argument("--qa-delta-positive-list", action="store_true", help="List positive delta rows.") p.add_argument("--qa-argmax-overall", action="store_true", help="Argmax over whole table.") p.add_argument("--qa-multi-hop-style-agg", action="store_true", help="Aggregate over styled cells.") p.add_argument("--qa-multi-hop-exclude-agg", action="store_true", help="Aggregate over non-styled cells.") p.add_argument("--qa-multi-hop-samples", type=int, default=2, help="Samples for multi-hop aggregation.") p.add_argument("--qa-counterfactual", action="store_true", help="Ask empty-result style questions.") # Congruency mode p.add_argument( "--congruency-mode", choices=["none", "congruent", "neutral", "incongruent", "mix"], default="none", help="Congruent: style markers align with max; Neutral: no style; Incongruent: style markers point to non-max.", ) p.add_argument("--qa-delta-col", action="store_true", help="Ask for all values in the delta column.") p.add_argument("--qa-delta-best-row", action="store_true", help="Ask for row with maximum delta.") p.add_argument("--qa-delta-samples", type=int, default=3, help="Number of delta value questions per image.") p.add_argument("--qa-template-json", default="question.json", help="Question template library JSON (optional).") p.add_argument("--probe-six", action="store_true", help="Generate 6 variants per base table.") p.add_argument("--probe-seven", action="store_true", help="Generate 7 unique style-counterfactual variants per base table.") p.add_argument("--task-name", default="HighlightBench", help="Task set name to store in JSON.") p.add_argument("--auto-abc", action="store_true", help="Auto switch A/B/C highlight behavior by palette id.") p.add_argument( "--gt-format", choices=["jsonl", "json", "both"], default="json", help="GT output format: jsonl (default), json, or both.", ) args = p.parse_args() rng = random.Random(args.seed) marker_combo_weights = [1.0, 1.0, 1.0] marker_combo_schedule: List[str] = [] if str(args.marker_combo_mode) == "three-way": try: marker_combo_weights = [float(x.strip()) for x in str(args.marker_combo_probs).split(",")] except Exception as e: raise SystemExit(f"--marker-combo-probs parse error: {e}") if len(marker_combo_weights) != 3: raise SystemExit("--marker-combo-probs must be 3 comma-separated numbers: underline_only,bold_only,both") if any(w < 0 for w in marker_combo_weights): raise SystemExit("--marker-combo-probs cannot contain negative values") if sum(marker_combo_weights) <= 0: raise SystemExit("--marker-combo-probs must have positive total weight") combo_names = ["underline_only", "bold_only", "both"] n_imgs = max(0, int(args.count)) guaranteed = [name for name, w in zip(combo_names, marker_combo_weights) if w > 0] if n_imgs > 0: if n_imgs >= len(guaranteed): marker_combo_schedule.extend(guaranteed) remain = n_imgs - len(guaranteed) else: ranked = sorted(zip(combo_names, marker_combo_weights), key=lambda x: x[1], reverse=True) marker_combo_schedule.extend([name for name, w in ranked[:n_imgs] if w > 0]) remain = 0 for _ in range(remain): marker_combo_schedule.append( rng.choices(combo_names, weights=marker_combo_weights, k=1)[0] ) rng.shuffle(marker_combo_schedule) shape_profile_names = ["compact", "wide", "tall", "dense_header"] shape_profile_weights = [1.0, 1.0, 1.0, 1.0] if str(args.table_shape_mode) == "mixed": try: shape_profile_weights = [float(x.strip()) for x in str(args.table_shape_profile_probs).split(",")] except Exception as e: raise SystemExit(f"--table-shape-profile-probs parse error: {e}") if len(shape_profile_weights) != 4: raise SystemExit("--table-shape-profile-probs must be 4 comma-separated numbers: compact,wide,tall,dense_header") if any(w < 0 for w in shape_profile_weights): raise SystemExit("--table-shape-profile-probs cannot contain negative values") if sum(shape_profile_weights) <= 0: raise SystemExit("--table-shape-profile-probs must have positive total weight") def _sample_table_shape_cfg() -> Dict[str, Any]: if args.top_levels == "random": top_levels_local = rng.choice([1, 2]) else: top_levels_local = int(args.top_levels) if args.left_levels == "random": left_levels_local = rng.choice([1, 2]) else: left_levels_local = int(args.left_levels) cfg: Dict[str, Any] = { "profile": "fixed", "group_count": int(args.group_count), "min_items": int(args.min_items), "max_items": int(args.max_items), "block_count": int(args.block_count), "min_metrics": int(args.min_metrics), "max_metrics": int(args.max_metrics), "mid_group_min": int(args.mid_groups_min), "mid_group_max": int(args.mid_groups_max), "section_count": int(args.section_count), "top_levels": int(top_levels_local), "left_levels": int(left_levels_local), } if str(args.table_shape_mode) != "mixed": return cfg profile = rng.choices(shape_profile_names, weights=shape_profile_weights, k=1)[0] cfg["profile"] = profile if args.top_levels == "random": if profile == "dense_header": cfg["top_levels"] = 2 elif profile == "wide": cfg["top_levels"] = rng.choice([1, 2, 2]) elif profile == "tall": cfg["top_levels"] = rng.choice([1, 2]) else: # compact cfg["top_levels"] = rng.choice([1, 2]) if args.left_levels == "random": if profile == "dense_header": cfg["left_levels"] = 2 elif profile == "tall": cfg["left_levels"] = rng.choice([1, 2, 2]) else: cfg["left_levels"] = rng.choice([1, 2]) if profile == "compact": cfg["group_count"] = _clamp_int(cfg["group_count"] - rng.choice([0, 1]), lo=1) cfg["block_count"] = _clamp_int(cfg["block_count"] - rng.choice([0, 1]), lo=1) cfg["min_items"] = _clamp_int(cfg["min_items"] - rng.choice([0, 1]), lo=2) cfg["max_items"] = _clamp_int(cfg["max_items"] - rng.choice([0, 1]), lo=cfg["min_items"]) cfg["min_metrics"] = _clamp_int(cfg["min_metrics"] - rng.choice([0, 1]), lo=1) cfg["max_metrics"] = _clamp_int(cfg["max_metrics"] - rng.choice([0, 1]), lo=cfg["min_metrics"]) cfg["mid_group_min"] = _clamp_int(cfg["mid_group_min"], lo=1) cfg["mid_group_max"] = _clamp_int(min(cfg["mid_group_max"], cfg["mid_group_min"] + 1), lo=cfg["mid_group_min"]) cfg["section_count"] = max(0, min(cfg["section_count"], 1)) elif profile == "wide": cfg["group_count"] = _clamp_int(cfg["group_count"] - rng.choice([0, 1]), lo=1) cfg["min_items"] = _clamp_int(cfg["min_items"] - rng.choice([0, 1]), lo=2) cfg["max_items"] = _clamp_int(cfg["max_items"], lo=cfg["min_items"]) cfg["block_count"] = _clamp_int(cfg["block_count"] + rng.choice([1, 1, 2]), lo=1) cfg["min_metrics"] = _clamp_int(cfg["min_metrics"] + rng.choice([0, 1]), lo=1) cfg["max_metrics"] = _clamp_int(cfg["max_metrics"] + rng.choice([1, 1, 2]), lo=cfg["min_metrics"]) if cfg["top_levels"] == 3: cfg["mid_group_min"] = _clamp_int(cfg["mid_group_min"] + rng.choice([0, 1]), lo=1) cfg["mid_group_max"] = _clamp_int(cfg["mid_group_max"] + rng.choice([1, 1, 2]), lo=cfg["mid_group_min"]) cfg["section_count"] = max(0, cfg["section_count"]) elif profile == "tall": cfg["group_count"] = _clamp_int(cfg["group_count"] + rng.choice([1, 1, 2]), lo=1) cfg["min_items"] = _clamp_int(cfg["min_items"] + rng.choice([0, 1]), lo=2) cfg["max_items"] = _clamp_int(cfg["max_items"] + rng.choice([1, 1, 2]), lo=cfg["min_items"]) cfg["block_count"] = _clamp_int(cfg["block_count"] - rng.choice([0, 1]), lo=1) cfg["min_metrics"] = _clamp_int(cfg["min_metrics"] - rng.choice([0, 1]), lo=1) cfg["max_metrics"] = _clamp_int(cfg["max_metrics"] - rng.choice([0, 1]), lo=cfg["min_metrics"]) cfg["section_count"] = max(cfg["section_count"], rng.choice([0, 1])) if cfg["top_levels"] == 3: cfg["mid_group_min"] = _clamp_int(cfg["mid_group_min"], lo=1) cfg["mid_group_max"] = _clamp_int(min(cfg["mid_group_max"], cfg["mid_group_min"] + 1), lo=cfg["mid_group_min"]) elif profile == "dense_header": cfg["group_count"] = _clamp_int(cfg["group_count"], lo=1) cfg["min_items"] = _clamp_int(cfg["min_items"] - rng.choice([0, 1]), lo=2) cfg["max_items"] = _clamp_int(cfg["max_items"], lo=cfg["min_items"]) cfg["block_count"] = _clamp_int(cfg["block_count"] + rng.choice([0, 1]), lo=1) cfg["min_metrics"] = _clamp_int(min(cfg["min_metrics"], 2), lo=1) cfg["max_metrics"] = _clamp_int(min(cfg["max_metrics"] + 1, max(2, cfg["max_metrics"])), lo=cfg["min_metrics"]) cfg["top_levels"] = 2 if args.top_levels == "random" else cfg["top_levels"] cfg["left_levels"] = 2 if args.left_levels == "random" else cfg["left_levels"] cfg["mid_group_min"] = _clamp_int(max(cfg["mid_group_min"], 1), lo=1) cfg["mid_group_max"] = _clamp_int(max(cfg["mid_group_max"], cfg["mid_group_min"] + 1), lo=cfg["mid_group_min"]) cfg["section_count"] = max(cfg["section_count"], rng.choice([1, 1, 2])) cfg["group_count"] = _clamp_int(cfg["group_count"], lo=1) cfg["block_count"] = _clamp_int(cfg["block_count"], lo=1) cfg["min_items"] = _clamp_int(cfg["min_items"], lo=1) cfg["max_items"] = _clamp_int(cfg["max_items"], lo=cfg["min_items"]) cfg["min_metrics"] = _clamp_int(cfg["min_metrics"], lo=1) cfg["max_metrics"] = _clamp_int(cfg["max_metrics"], lo=cfg["min_metrics"]) cfg["mid_group_min"] = _clamp_int(cfg["mid_group_min"], lo=1) cfg["mid_group_max"] = _clamp_int(cfg["mid_group_max"], lo=cfg["mid_group_min"]) cfg["section_count"] = max(0, min(3, int(cfg["section_count"]))) cfg["top_levels"] = _clamp_int(int(cfg["top_levels"]), lo=1, hi=(2 if args.top_levels == "random" else 3)) cfg["left_levels"] = _clamp_int(int(cfg["left_levels"]), lo=1, hi=2) return cfg qa_lib = _load_question_library(args.qa_template_json) cfg_info = build_config_info( vars(args), exclude={"out_dir", "count", "seed", "qa_template_json"}, ) out_dir = Path(args.out_dir) out_dir.mkdir(parents=True, exist_ok=True) (out_dir / "images").mkdir(parents=True, exist_ok=True) (out_dir / "ann").mkdir(parents=True, exist_ok=True) m = [int(x) for x in args.margins.split(",")] if len(m) != 4: raise SystemExit("--margins must be 4 comma-separated ints") margins = (m[0], m[1], m[2], m[3]) def _build_spec_with_readability_retries( initial_shape_cfg: Dict[str, Any], builder_fn, *, max_retries: int = 24, ) -> Tuple[TableSpec, Dict[str, Any]]: """Build a table spec and retry when the layout is too dense for the canvas/font.""" shape_cfg_local = dict(initial_shape_cfg) last_spec: Optional[TableSpec] = None for _attempt in range(max(1, int(max_retries))): spec_try = builder_fn(shape_cfg_local) last_spec = spec_try if _spec_layout_is_readable( spec_try, canvas_width=int(args.canvas_width), canvas_height=int(args.canvas_height), margins=margins, font_path=args.font_path, font_size=int(args.font_size), arrow_scale=float(args.arrow_scale), ): return spec_try, shape_cfg_local if str(args.table_shape_mode) == "mixed": shape_cfg_local = _sample_table_shape_cfg() raise SystemExit( "Failed to generate a readable table layout after multiple retries. " "Try increasing canvas size, reducing table density (groups/blocks/metrics), or lowering font size." ) gt_path = out_dir / "gt.jsonl" gt_json_path = out_dir / "gt.json" qa_full_path = out_dir / "qa_full.jsonl" qa_path = out_dir / "qa.jsonl" qid_counter = 1 gt_records: List[Dict] = [] write_jsonl = args.gt_format in ("jsonl", "both") write_json = args.gt_format in ("json", "both") fgt = gt_path.open("w", encoding="utf-8") if write_jsonl else None try: with qa_full_path.open("w", encoding="utf-8") as fqa: palettes = None if args.highlight_palettes: palettes = [] for i, pal in enumerate(_parse_palettes(args.highlight_palettes)): palettes.append({"id": f"custom_{i}", "palette": pal, "names": None}) if args.highlight_palettes_file: try: data = json.loads(Path(args.highlight_palettes_file).read_text(encoding="utf-8")) file_pals = [] for k, v in data.items(): if isinstance(v, dict) and "palette" in v: file_pals.append({"id": str(k), "palette": v["palette"], "names": v.get("names")}) elif isinstance(v, list): file_pals.append({"id": str(k), "palette": v, "names": None}) if file_pals: palettes = (palettes or []) + file_pals except Exception: pass # probe-seven: build A-color pool for per-image single-color highlighting probe_a_color_entries: List[Dict[str, str]] = [] if args.probe_seven: def _append_probe_color(hex_color: Any, name: Any = None) -> None: h = str(hex_color or "").strip().upper() if not h: return if not h.startswith("#"): h = "#" + h if len(h) != 7: return probe_a_color_entries.append({"hex": h, "name": str(name or "")}) # Prefer loaded palettes (if present), filter A-group if palettes: for p in palettes: if _palette_group_from_id(str(p.get("id", ""))) != "A": continue pal = p.get("palette") or [] names = p.get("names") if isinstance(p.get("names"), dict) else {} for hx in pal: n = None if isinstance(names, dict): hxs = str(hx) n = names.get(hxs) or names.get(hxs.upper()) or names.get(hxs.lower()) _append_probe_color(hx, n) # Fallback to canonical palette file in repo if not probe_a_color_entries: pf = Path("highlight/palette_preview/index.json") if pf.exists(): try: pdata = json.loads(pf.read_text(encoding="utf-8")) for pid, pv in pdata.items(): if _palette_group_from_id(str(pid)) != "A": continue if not isinstance(pv, dict): continue pal = pv.get("palette") or [] names = pv.get("names") if isinstance(pv.get("names"), dict) else {} for hx in pal: hxs = str(hx) n = names.get(hxs) or names.get(hxs.upper()) or names.get(hxs.lower()) _append_probe_color(hx, n) except Exception: pass # Last-resort: small A-like fallback pool if not probe_a_color_entries: fallback = [ ("#D3FAEE", "light_teal"), ("#83EDC4", "mid_teal"), ("#22D28E", "dark_teal"), ("#FEF4B8", "light_yellow"), ("#F7DA67", "mid_yellow"), ("#EFBC23", "dark_yellow"), ("#FFD1E7", "light_pink"), ("#FC88BC", "mid_pink"), ("#F74B98", "dark_pink"), ] for hx, n in fallback: _append_probe_color(hx, n) for i in range(1, args.count + 1): shape_cfg = _sample_table_shape_cfg() top_levels = int(shape_cfg["top_levels"]) left_levels = int(shape_cfg["left_levels"]) shape_profile = str(shape_cfg.get("profile", "fixed")) use_config_rows = bool(args.config_rows) and (rng.random() < float(args.config_rows_prob)) highlight_colors = _parse_palette(args.highlight_colors) palette_id = "default" palette_names: Optional[Dict[str, str]] = None if palettes: if use_config_rows: candidates = [p for p in palettes if _palette_group_from_id(p.get("id", "")) in ("B", "C")] picked = rng.choice(candidates) if candidates else rng.choice(palettes) elif args.probe_six or args.probe_seven: candidates = [p for p in palettes if _palette_group_from_id(p.get("id", "")) == "A"] picked = rng.choice(candidates) if candidates else rng.choice(palettes) else: picked = rng.choice(palettes) highlight_colors = picked["palette"] palette_id = picked["id"] palette_names = picked.get("names") palette_group = _palette_group_from_id(palette_id) palette_group_id = {"A": 1, "B": 2, "C": 3}.get(palette_group, 0) effective_highlight_strategy = str(args.highlight_strategy) effective_highlight_mode = str(args.highlight_mode) effective_use_all = bool(args.highlight_use_all_colors) if args.auto_abc: if palette_group == "A": effective_highlight_strategy = "by_column_rank" effective_use_all = True elif palette_group in ("B", "C"): effective_highlight_strategy = "random" effective_highlight_mode = "multi" underline_overall = float(args.underline_image_prob_overall) if underline_overall >= 0.0: if args.auto_abc: if palettes: total = len(palettes) count_a = sum(1 for p in palettes if _palette_group_from_id(p.get("id", "")) == "A") p_a = (count_a / total) if total > 0 else 0.0 else: p_a = 0.0 if palette_group == "A": apply_underline = False else: denom = max(1e-6, (1.0 - p_a)) prob_bc = min(1.0, underline_overall / denom) apply_underline = rng.random() < prob_bc else: apply_underline = rng.random() < underline_overall else: if args.auto_abc and palette_group == "A": apply_underline = False else: apply_underline = rng.random() < float(args.underline_image_prob) bold_overall = float(args.bold_image_prob_overall) if bold_overall >= 0.0: if args.auto_abc: if palettes: total = len(palettes) count_a = sum(1 for p in palettes if _palette_group_from_id(p.get("id", "")) == "A") p_a = (count_a / total) if total > 0 else 0.0 else: p_a = 0.0 if palette_group == "A": apply_bold = False else: denom = max(1e-6, (1.0 - p_a)) prob_bc = min(1.0, bold_overall / denom) apply_bold = rng.random() < prob_bc else: apply_bold = rng.random() < bold_overall else: if args.auto_abc and palette_group == "A": apply_bold = False else: apply_bold = rng.random() < float(args.bold_image_prob) apply_text_color = rng.random() < float(args.text_color_image_prob) marker_combo_pick = "independent" if str(args.marker_combo_mode) == "three-way": if marker_combo_schedule and (i - 1) < len(marker_combo_schedule): combo = marker_combo_schedule[i - 1] else: combo = rng.choices( ["underline_only", "bold_only", "both"], weights=marker_combo_weights, k=1, )[0] marker_combo_pick = str(combo) apply_underline = combo in ("underline_only", "both") apply_bold = combo in ("bold_only", "both") effective_text_color_delta_sign = bool(args.text_color_delta_sign) effective_text_color_best_per_col = bool(args.text_color_best_per_col) if args.auto_abc and palette_group == "A": effective_text_color_best_per_col = False if args.probe_six or args.probe_seven: def _build_probe_base_spec(shape_cfg_try: Dict[str, Any]) -> TableSpec: return build_paper_table( rng, group_count=int(shape_cfg_try["group_count"]), min_items=int(shape_cfg_try["min_items"]), max_items=int(shape_cfg_try["max_items"]), block_count=int(shape_cfg_try["block_count"]), min_metrics=int(shape_cfg_try["min_metrics"]), max_metrics=int(shape_cfg_try["max_metrics"]), mid_group_min=int(shape_cfg_try["mid_group_min"]), mid_group_max=int(shape_cfg_try["mid_group_max"]), section_count=int(shape_cfg_try["section_count"]), unique_numbers=bool(args.unique_numbers), top_levels=int(shape_cfg_try["top_levels"]), left_levels=int(shape_cfg_try["left_levels"]), merge_group_prob=args.merge_group_prob, citation_prob=args.citation_prob, missing_prob=args.missing_prob, dec_min=args.dec_min, dec_max=args.dec_max, highlight=False, highlight_mode="single", highlight_rate=0.0, highlight_count=0, highlight_colors=highlight_colors, highlight_use_all_colors=True, highlight_strategy="random", highlight_rank_k=int(args.highlight_rank_k), underline_rate=0.0, underline_best_per_col=False, underline_second_per_col=False, underline_wrong_per_col=False, bold_rate=0.0, bold_best_per_col=False, bold_wrong_per_col=False, text_color_delta_sign=False, text_color_best_per_col=False, text_color_pos_hex=str(args.text_color_pos_hex), text_color_neg_hex=str(args.text_color_neg_hex), text_color_best_hex=str(args.text_color_best_hex), arrow_rate=float(args.arrow_rate), arrow_up_ratio=float(args.arrow_up_ratio), data_arrows=bool(args.data_arrows), metric_arrow_prob=float(args.metric_arrow_prob), config_rows=bool(use_config_rows), config_flag_pool=( [x.strip() for x in str(args.config_flag_pool).split(",") if x.strip()] if args.config_flag_pool else list(CONFIG_FLAG_POOL) ), config_shade_best_row=bool(args.config_shade_best_row), ) base_spec, shape_cfg = _build_spec_with_readability_retries(shape_cfg, _build_probe_base_spec) top_levels = int(shape_cfg["top_levels"]) left_levels = int(shape_cfg["left_levels"]) shape_profile = str(shape_cfg.get("profile", "fixed")) probe_single_hl_hex = str(rng.choice(highlight_colors)).upper() if highlight_colors else "#E6F2FF" probe_single_hl_name = "" probe_palette_id = palette_id probe_palette_colors = list(highlight_colors) probe_palette_names = palette_names if args.probe_seven and probe_a_color_entries: picked_probe_color = rng.choice(probe_a_color_entries) probe_single_hl_hex = str(picked_probe_color.get("hex") or probe_single_hl_hex).upper() probe_single_hl_name = str(picked_probe_color.get("name") or "").strip() probe_palette_id = f"A_single_{probe_single_hl_hex.lstrip('#')}" probe_palette_colors = [probe_single_hl_hex] probe_palette_names = {probe_single_hl_hex: probe_single_hl_name} if probe_single_hl_name else None if args.probe_seven: variants = [ ("none", "neutral"), ("highlight", "congruent"), ("highlight", "incongruent"), ("underline", "congruent"), ("underline", "incongruent"), ("bold", "congruent"), ("bold", "incongruent"), ] else: variants = [ ("highlight", "congruent"), ("highlight", "neutral"), ("highlight", "incongruent"), ("underline", "congruent"), ("underline", "neutral"), ("underline", "incongruent"), ] for style_var, congruency in variants: spec = copy.deepcopy(base_spec) _clear_style_marks(spec.cells) if style_var == "highlight": if congruency == "congruent": _apply_highlight_best_per_col( spec.cells, left_cols=spec.left_cols, data_cols_len=len(spec.data_cols), color_hex=probe_single_hl_hex, col_metrics=[str(ci.get("metric", "")) for ci in spec.data_cols], ) elif congruency == "incongruent": _apply_highlight_by_column_wrong( rng, spec.cells, left_cols=spec.left_cols, data_cols_len=len(spec.data_cols), colors=[probe_single_hl_hex], col_metrics=[str(ci.get("metric", "")) for ci in spec.data_cols], ) # Exp1 probe setting: use a single A-palette color per image for all highlighted cells. if args.probe_seven: hl_cells = [c for c in spec.cells if c.extra.get("highlight") == "true"] if not hl_cells: data_cells = [c for c in spec.cells if c.kind == "data" and c.value is not None] if data_cells: picked = rng.choice(data_cells) picked.extra["highlight"] = "true" hl_cells = [picked] if hl_cells: for c in hl_cells: c.extra["highlight"] = "true" c.extra["highlight_color"] = probe_single_hl_hex c.extra.pop("highlight_color_name", None) elif style_var == "underline": if congruency == "congruent": _apply_underline_best_per_col( spec.cells, left_cols=spec.left_cols, data_cols_len=len(spec.data_cols), col_metrics=[str(ci.get("metric", "")) for ci in spec.data_cols], ) elif congruency == "incongruent": _apply_underline_wrong_per_col( rng, spec.cells, left_cols=spec.left_cols, data_cols_len=len(spec.data_cols), col_metrics=[str(ci.get("metric", "")) for ci in spec.data_cols], ) elif style_var == "bold": if congruency == "congruent": _apply_bold_best_per_col( spec.cells, left_cols=spec.left_cols, data_cols_len=len(spec.data_cols), col_metrics=[str(ci.get("metric", "")) for ci in spec.data_cols], ) elif congruency == "incongruent": _apply_bold_wrong_per_col( rng, spec.cells, left_cols=spec.left_cols, data_cols_len=len(spec.data_cols), col_metrics=[str(ci.get("metric", "")) for ci in spec.data_cols], ) if style_var == "highlight" and congruency != "neutral": name_map = _build_palette_color_names(probe_palette_colors, explicit=probe_palette_names) for c in spec.cells: if c.extra.get("highlight") == "true": hex_color = (c.extra.get("highlight_color") or "").upper() if hex_color: c.extra["highlight_color_name"] = name_map.get(hex_color, "") if style_var == "none": code = "N" else: style_code = {"highlight": "H", "underline": "U", "bold": "B"}[style_var] cong_code = { "congruent": "C", "neutral": "N", "incongruent": "I", }[congruency] code = style_code + cong_code image_id = f"img_{i:05d}_{code}.png" image_path = out_dir / "images" / image_id render_table( spec, out_path=image_path, canvas_width=args.canvas_width, canvas_height=args.canvas_height, margins=margins, font_path=args.font_path, font_size=args.font_size, line_style=args.line_style, block_sep=args.block_sep, number_align=args.number_align, arrow_offset=(int(args.arrow_offset_x), int(args.arrow_offset_y)), arrow_scale=float(args.arrow_scale), delta_pm_scale=float(args.delta_pm_scale), crop_to_table=bool(args.crop_to_table), crop_pad=int(args.crop_pad), ) # GT gt_cells = [] for c in spec.cells: x1, y1, x2, y2 = c.bbox or (0, 0, 0, 0) gt_cells.append( { "row": c.row, "col": c.col, "row_span": c.row_span, "col_span": c.col_span, "text": c.text, "value": c.value, "bbox": [x1, y1, x2, y2], "kind": c.kind, "extra": c.extra, } ) gt = { "image_id": image_id, "n_rows": spec.n_rows, "n_cols": spec.n_cols, "header_rows": spec.header_rows, "top_levels": spec.top_levels, "left_levels": spec.left_levels, "left_cols": spec.left_cols, "highlight_palette": probe_palette_colors, "highlight_palette_id": probe_palette_id, "highlight_palette_group": "A", "highlight_palette_group_id": 1, "task_name": args.task_name, "task_variant": style_var, "task_variant_id": 0, "table_shape_profile": shape_profile, "cells": gt_cells, "config_id": cfg_info["config_id"], "config_code": cfg_info["config_code"], "config_json": cfg_info["config_json"], "probe_style": style_var, "probe_congruency": congruency, "probe_family": ("style_counterfactual_v2" if args.probe_seven else "style_counterfactual_v1"), } if write_jsonl and fgt: fgt.write(json.dumps(gt, ensure_ascii=False) + "\n") if write_json: gt_records.append(gt) # QA qa_items = generate_qa( spec, rng, include_cell_lookup=bool(args.qa_cell_lookup), cell_lookup_samples=int(args.qa_cell_lookup_samples), include_position=bool(args.qa_position), position_samples=int(args.qa_position_samples), include_col_extremes=bool(args.qa_col_extremes), col_extremes_k=int(args.qa_col_extremes_k), include_row_extremes=bool(args.qa_row_extremes), row_extremes_k=int(args.qa_row_extremes_k), include_col_argmax_item=bool(args.qa_col_argmax_item), include_col_argmax_coord=bool(args.qa_col_argmax_coord), include_topk=bool(args.qa_topk), topk_k=int(args.qa_topk_k), topk_cols=int(args.qa_topk_cols), include_kth=bool(args.qa_kth), kth_k=int(args.qa_kth_k), include_compare_rows=bool(args.qa_compare_rows), include_compare_cols=bool(args.qa_compare_cols), compare_samples=int(args.qa_compare_samples), include_col_best=bool(args.qa_col_best), include_group_col_best=bool(args.qa_group_col_best), include_highlight_neighbor=bool(args.qa_highlight_neighbor), highlight_neighbor_samples=int(args.qa_highlight_neighbor_samples), include_neighbors_idx=bool(args.qa_neighbors_idx), include_neighbors_noidx=bool(args.qa_neighbors_noidx), neighbor_samples=int(args.qa_neighbor_samples), include_color_values=bool(args.qa_color_values), palette_id=probe_palette_id, palette_colors=probe_palette_colors, palette_names=probe_palette_names, include_same_color=bool(args.qa_same_color), same_color_samples=int(args.qa_same_color_samples), include_same_color_noidx=bool(args.qa_same_color_noidx), same_color_noidx_samples=int(args.qa_same_color_noidx_samples), include_text_color_values=bool(args.qa_text_color_values), include_underline_values=bool(args.qa_underline), include_underline_per_col=bool(args.qa_underline_per_col), include_underline_yesno_idx=bool(args.qa_underline_yesno_idx), include_underline_yesno_noidx=bool(args.qa_underline_yesno_noidx), underline_yesno_samples=int(args.qa_underline_yesno_samples), include_bold_values=bool(args.qa_bold), include_bold_per_col=bool(args.qa_bold_per_col), include_bold_yesno_idx=bool(args.qa_bold_yesno_idx), include_bold_yesno_noidx=bool(args.qa_bold_yesno_noidx), bold_yesno_samples=int(args.qa_bold_yesno_samples), include_color_yesno_idx=bool(args.qa_color_yesno_idx), include_color_yesno_noidx=bool(args.qa_color_yesno_noidx), color_yesno_samples=int(args.qa_color_yesno_samples), include_missing_list=bool(args.qa_missing_list), include_missing_check=bool(args.qa_missing_check), missing_samples=int(args.qa_missing_samples), include_count_highlight=bool(args.qa_count_highlight), include_count_underline=bool(args.qa_count_underline), include_count_bold=bool(args.qa_count_bold), include_filter_threshold=bool(args.qa_filter_threshold), include_filter_highlight_threshold=bool(args.qa_filter_highlight_threshold), filter_samples=int(args.qa_filter_samples), include_agg_mean_group=bool(args.qa_agg_mean_group), include_delta_positive_list=bool(args.qa_delta_positive_list), include_argmax_overall=bool(args.qa_argmax_overall), include_multi_hop_style_agg=bool(args.qa_multi_hop_style_agg), include_multi_hop_exclude_agg=bool(args.qa_multi_hop_exclude_agg), multi_hop_samples=int(args.qa_multi_hop_samples), include_counterfactual=bool(args.qa_counterfactual), include_delta_values=bool(args.qa_delta_col), include_delta_best_row=bool(args.qa_delta_best_row), delta_samples=int(args.qa_delta_samples), qa_lib=qa_lib, ) for item in qa_items: item_out = { "image_id": image_id, "image_path": f"images/{image_id}", "qid": f"q{qid_counter:06d}", "task_id": item["task_id"], "qa_task_name": item.get("qa_task_name"), "qa_category": item.get("qa_category"), "qa_category_id": item.get("qa_category_id"), "table_shape_profile": shape_profile, "question": item["question"], "answer": item["answer"], "answer_type": item.get("answer_type", "string"), "scoring": item.get("scoring", {"type": "exact"}), "expected_format": item.get("expected_format", {"type": "string"}), "meta": item.get("meta", {}), "task_name": args.task_name, "task_variant": style_var, "task_variant_id": 0, "highlight_palette_id": probe_palette_id, "config_id": cfg_info["config_id"], "config_code": cfg_info["config_code"], "probe_style": style_var, "probe_congruency": congruency, "probe_family": ("style_counterfactual_v2" if args.probe_seven else "style_counterfactual_v1"), } fqa.write(json.dumps(item_out, ensure_ascii=False) + "\n") qid_counter += 1 # per-image ann ann = {"image_id": image_id, "image_path": f"images/{image_id}", "gt": gt, "qa": qa_items} (out_dir / "ann" / f"{Path(image_id).stem}.json").write_text( json.dumps(ann, ensure_ascii=False, indent=2), encoding="utf-8", ) continue congruency = str(args.congruency_mode) if congruency == "mix": congruency = rng.choice(["congruent", "neutral", "incongruent"]) effective_highlight = bool(args.highlight) underline_best = bool(args.underline_best_per_col) underline_second = bool(args.underline_second_per_col) underline_wrong = bool(args.underline_wrong_per_col) bold_best = bool(args.bold_best_per_col) bold_wrong = bool(args.bold_wrong_per_col) if str(args.marker_combo_mode) == "three-way" and str(args.marker_role_policy) == "paper": if marker_combo_pick == "underline_only": underline_best = True underline_second = False underline_wrong = False bold_best = False bold_wrong = False elif marker_combo_pick == "bold_only": underline_best = False underline_second = False underline_wrong = False bold_best = True bold_wrong = False elif marker_combo_pick == "both": underline_best = False underline_second = True underline_wrong = False bold_best = True bold_wrong = False if congruency != "none": if congruency == "neutral": effective_highlight = False apply_underline = False underline_best = False underline_second = False underline_wrong = False apply_bold = False bold_best = False bold_wrong = False elif congruency == "congruent": effective_highlight = True effective_highlight_strategy = "by_column_rank" if float(args.underline_image_prob) > 0: apply_underline = True underline_best = True underline_second = False underline_wrong = False if float(args.bold_image_prob) > 0: apply_bold = True bold_best = True bold_wrong = False elif congruency == "incongruent": effective_highlight = True effective_highlight_strategy = "by_column_wrong" if float(args.underline_image_prob) > 0: apply_underline = True underline_best = False underline_second = False underline_wrong = True if float(args.bold_image_prob) > 0: apply_bold = True bold_best = False bold_wrong = True if not apply_bold: bold_best = False bold_wrong = False if not apply_underline: underline_best = False underline_second = False underline_wrong = False def _build_main_spec(shape_cfg_try: Dict[str, Any]) -> TableSpec: return build_paper_table( rng, group_count=int(shape_cfg_try["group_count"]), min_items=int(shape_cfg_try["min_items"]), max_items=int(shape_cfg_try["max_items"]), block_count=int(shape_cfg_try["block_count"]), min_metrics=int(shape_cfg_try["min_metrics"]), max_metrics=int(shape_cfg_try["max_metrics"]), mid_group_min=int(shape_cfg_try["mid_group_min"]), mid_group_max=int(shape_cfg_try["mid_group_max"]), section_count=int(shape_cfg_try["section_count"]), unique_numbers=bool(args.unique_numbers), top_levels=int(shape_cfg_try["top_levels"]), left_levels=int(shape_cfg_try["left_levels"]), merge_group_prob=args.merge_group_prob, citation_prob=args.citation_prob, missing_prob=args.missing_prob, dec_min=args.dec_min, dec_max=args.dec_max, highlight=bool(effective_highlight), highlight_mode=effective_highlight_mode, highlight_rate=float(args.highlight_rate), highlight_count=int(args.highlight_count), highlight_colors=highlight_colors, highlight_use_all_colors=effective_use_all, highlight_strategy=effective_highlight_strategy, highlight_rank_k=int(args.highlight_rank_k), underline_rate=float(args.underline_rate) if apply_underline else 0.0, underline_best_per_col=bool(underline_best) if apply_underline else False, underline_second_per_col=bool(underline_second) if apply_underline else False, underline_wrong_per_col=bool(underline_wrong) if apply_underline else False, bold_rate=float(args.bold_rate) if apply_bold else 0.0, bold_best_per_col=bool(bold_best) if apply_bold else False, bold_wrong_per_col=bool(bold_wrong) if apply_bold else False, text_color_delta_sign=effective_text_color_delta_sign if apply_text_color else False, text_color_best_per_col=effective_text_color_best_per_col if apply_text_color else False, text_color_pos_hex=str(args.text_color_pos_hex), text_color_neg_hex=str(args.text_color_neg_hex), text_color_best_hex=str(args.text_color_best_hex), arrow_rate=float(args.arrow_rate), arrow_up_ratio=float(args.arrow_up_ratio), data_arrows=bool(args.data_arrows), metric_arrow_prob=float(args.metric_arrow_prob), config_rows=bool(use_config_rows), config_flag_pool=( [x.strip() for x in str(args.config_flag_pool).split(",") if x.strip()] if args.config_flag_pool else list(CONFIG_FLAG_POOL) ), config_shade_best_row=bool(args.config_shade_best_row), ) spec, shape_cfg = _build_spec_with_readability_retries(shape_cfg, _build_main_spec) top_levels = int(shape_cfg["top_levels"]) left_levels = int(shape_cfg["left_levels"]) shape_profile = str(shape_cfg.get("profile", "fixed")) if args.highlight: name_map = _build_palette_color_names(highlight_colors, explicit=palette_names) for c in spec.cells: if c.extra.get("highlight") == "true": hex_color = (c.extra.get("highlight_color") or "").upper() if hex_color: c.extra["highlight_color_name"] = name_map.get(hex_color, "") image_id = f"img_{i:05d}.png" image_path = out_dir / "images" / image_id render_table( spec, out_path=image_path, canvas_width=args.canvas_width, canvas_height=args.canvas_height, margins=margins, font_path=args.font_path, font_size=args.font_size, line_style=args.line_style, block_sep=args.block_sep, number_align=args.number_align, arrow_offset=(int(args.arrow_offset_x), int(args.arrow_offset_y)), arrow_scale=float(args.arrow_scale), delta_pm_scale=float(args.delta_pm_scale), crop_to_table=bool(args.crop_to_table), crop_pad=int(args.crop_pad), ) # GT gt_cells = [] for c in spec.cells: x1, y1, x2, y2 = c.bbox or (0, 0, 0, 0) gt_cells.append( { "row": c.row, "col": c.col, "row_span": c.row_span, "col_span": c.col_span, "text": c.text, "value": c.value, "bbox": [x1, y1, x2, y2], "kind": c.kind, "extra": c.extra, } ) gt = { "image_id": image_id, "n_rows": spec.n_rows, "n_cols": spec.n_cols, "header_rows": spec.header_rows, "top_levels": spec.top_levels, "left_levels": spec.left_levels, "left_cols": spec.left_cols, "highlight_palette": highlight_colors, "highlight_palette_id": palette_id, "highlight_palette_group": palette_group, "highlight_palette_group_id": palette_group_id, "congruency": congruency, "task_name": args.task_name, "task_variant": palette_group, "task_variant_id": palette_group_id, "table_shape_profile": shape_profile, "cells": gt_cells, "config_id": cfg_info["config_id"], "config_code": cfg_info["config_code"], "config_json": cfg_info["config_json"], } if write_jsonl and fgt: fgt.write(json.dumps(gt, ensure_ascii=False) + "\n") if write_json: gt_records.append(gt) # QA qa_items = generate_qa( spec, rng, include_cell_lookup=bool(args.qa_cell_lookup), cell_lookup_samples=int(args.qa_cell_lookup_samples), include_position=bool(args.qa_position), position_samples=int(args.qa_position_samples), include_col_extremes=bool(args.qa_col_extremes), col_extremes_k=int(args.qa_col_extremes_k), include_row_extremes=bool(args.qa_row_extremes), row_extremes_k=int(args.qa_row_extremes_k), include_col_argmax_item=bool(args.qa_col_argmax_item), include_col_argmax_coord=bool(args.qa_col_argmax_coord), include_topk=bool(args.qa_topk), topk_k=int(args.qa_topk_k), topk_cols=int(args.qa_topk_cols), include_kth=bool(args.qa_kth), kth_k=int(args.qa_kth_k), include_compare_rows=bool(args.qa_compare_rows), include_compare_cols=bool(args.qa_compare_cols), compare_samples=int(args.qa_compare_samples), include_col_best=bool(args.qa_col_best), include_group_col_best=bool(args.qa_group_col_best), include_highlight_neighbor=bool(args.qa_highlight_neighbor), highlight_neighbor_samples=int(args.qa_highlight_neighbor_samples), include_neighbors_idx=bool(args.qa_neighbors_idx), include_neighbors_noidx=bool(args.qa_neighbors_noidx), neighbor_samples=int(args.qa_neighbor_samples), include_color_values=bool(args.qa_color_values), palette_id=palette_id, palette_colors=highlight_colors, palette_names=palette_names, include_same_color=bool(args.qa_same_color), same_color_samples=int(args.qa_same_color_samples), include_same_color_noidx=bool(args.qa_same_color_noidx), same_color_noidx_samples=int(args.qa_same_color_noidx_samples), include_text_color_values=bool(args.qa_text_color_values), include_underline_values=bool(args.qa_underline), include_underline_per_col=bool(args.qa_underline_per_col), include_underline_yesno_idx=bool(args.qa_underline_yesno_idx), include_underline_yesno_noidx=bool(args.qa_underline_yesno_noidx), underline_yesno_samples=int(args.qa_underline_yesno_samples), include_bold_values=bool(args.qa_bold), include_bold_per_col=bool(args.qa_bold_per_col), include_bold_yesno_idx=bool(args.qa_bold_yesno_idx), include_bold_yesno_noidx=bool(args.qa_bold_yesno_noidx), bold_yesno_samples=int(args.qa_bold_yesno_samples), include_color_yesno_idx=bool(args.qa_color_yesno_idx), include_color_yesno_noidx=bool(args.qa_color_yesno_noidx), color_yesno_samples=int(args.qa_color_yesno_samples), include_missing_list=bool(args.qa_missing_list), include_missing_check=bool(args.qa_missing_check), missing_samples=int(args.qa_missing_samples), include_count_highlight=bool(args.qa_count_highlight), include_count_underline=bool(args.qa_count_underline), include_count_bold=bool(args.qa_count_bold), include_filter_threshold=bool(args.qa_filter_threshold), include_filter_highlight_threshold=bool(args.qa_filter_highlight_threshold), filter_samples=int(args.qa_filter_samples), include_agg_mean_group=bool(args.qa_agg_mean_group), include_delta_positive_list=bool(args.qa_delta_positive_list), include_argmax_overall=bool(args.qa_argmax_overall), include_multi_hop_style_agg=bool(args.qa_multi_hop_style_agg), include_multi_hop_exclude_agg=bool(args.qa_multi_hop_exclude_agg), multi_hop_samples=int(args.qa_multi_hop_samples), include_counterfactual=bool(args.qa_counterfactual), include_delta_values=bool(args.qa_delta_col), include_delta_best_row=bool(args.qa_delta_best_row), delta_samples=int(args.qa_delta_samples), qa_lib=qa_lib, ) for item in qa_items: item_out = { "image_id": image_id, "image_path": f"images/{image_id}", "qid": f"q{qid_counter:06d}", "task_id": item["task_id"], "qa_task_name": item.get("qa_task_name"), "qa_category": item.get("qa_category"), "qa_category_id": item.get("qa_category_id"), "table_shape_profile": shape_profile, "question": item["question"], "answer": item["answer"], "answer_type": item.get("answer_type", "string"), "scoring": item.get("scoring", {"type": "exact"}), "expected_format": item.get("expected_format", {"type": "string"}), "meta": item.get("meta", {}), "task_name": args.task_name, "task_variant": palette_group, "task_variant_id": palette_group_id, "highlight_palette_id": palette_id, "congruency": congruency, "config_id": cfg_info["config_id"], "config_code": cfg_info["config_code"], } fqa.write(json.dumps(item_out, ensure_ascii=False) + "\n") qid_counter += 1 # per-image ann ann = { "image_id": image_id, "image_path": f"images/{image_id}", "gt": gt, "qa": qa_items, } (out_dir / "ann" / f"{Path(image_id).stem}.json").write_text( json.dumps(ann, ensure_ascii=False, indent=2), encoding="utf-8", ) if write_json: gt_json_path.write_text(json.dumps(gt_records, ensure_ascii=False, indent=2), encoding="utf-8") finally: if fgt: fgt.close() _write_clean_qa(qa_full_path, qa_path) return 0 if __name__ == "__main__": raise SystemExit(main())