"""Reference scorer for the chart-parsing benchmark.

Usage:
    python score.py --benchmark-repo nutrientdocs/chart-parsing-benchmark --predictions preds.jsonl --out result.json --name my-model

`preds.jsonl` holds one JSON object per line: {"id": "<chart id>", "text": "<raw model output>"}.
The JSON object inside `text` is extracted and scored; anything around it is ignored.
Only `datasets` is required. Generated from utils/tables.py and training/evaluation.py of the
chart-parsing-model repository; do not edit by hand.
"""
import argparse


import json
import math

AXIS_CHANNELS = ("x", "y", "z")


def extract_target(text):
    if isinstance(text, dict):
        return text
    if not text:
        return {}
    depth = 0
    start = -1
    for index, char in enumerate(text):
        if char == "{":
            if depth == 0:
                start = index
            depth += 1
        elif char == "}" and depth > 0:
            depth -= 1
            if depth == 0 and start != -1:
                try:
                    return json.loads(text[start:index + 1])
                except json.JSONDecodeError:
                    start = -1
    return {}


def _column_names(columns):
    return [str(column.get("name")) if isinstance(column, dict) else str(column) for column in columns]


def _is_blank(value):
    return value is None or (isinstance(value, str) and value.strip() == "")


def _normalize_label(value):
    number = to_number(str(value))
    if number is None:
        return str(value).strip().lower()
    return str(int(number)) if number.is_integer() else repr(number)


def _label_column_positions(rows, width):
    positions = {0}
    for index in range(1, width):
        values = [row[index] for row in rows if index < len(row) and not _is_blank(row[index])]
        if values and all(to_number(str(value)) is None for value in values):
            positions.add(index)
    return positions


ANY_COLUMN = "*"


def _value_positions(rows, width, label_positions):
    positions = []
    for index in range(width):
        if index in label_positions:
            continue
        if any(index < len(row) and not _is_blank(row[index]) for row in rows):
            positions.append(index)
    return positions


def _rows_are_constant(rows, value_positions):
    for row in rows:
        values = {str(row[index]) for index in value_positions if index < len(row) and not _is_blank(row[index])}
        if len(values) > 1:
            return False
    return True


def data_cells(columns, rows):
    if not isinstance(columns, list) or not isinstance(rows, list):
        return {}
    rows = [row for row in rows if isinstance(row, (list, tuple)) and row]
    if not rows:
        return {}
    names = [name.strip().lower() for name in _column_names(columns)]
    width = max(len(row) for row in rows)
    spatial = any(isinstance(column, dict) and column.get("role") == "z" for column in columns)
    label_positions = _label_column_positions(rows, width)
    if spatial:
        label_positions |= {index for index,column in enumerate(columns) if isinstance(column,dict) and column.get("role") in ("x","y")}
    value_positions = _value_positions(rows, width, label_positions)
    collapse = len(value_positions) == 1 or _rows_are_constant(rows, value_positions)
    cells = {}
    occurrences = {}
    for row in rows:
        identity = tuple(f"{(columns[index].get('role', names[index]) if index < len(columns) and isinstance(columns[index],dict) else f'col{index}')}={_normalize_label(row[index])}" for index in sorted(label_positions) if index < len(row)) if spatial else tuple(sorted(_normalize_label(row[index]) for index in label_positions if index < len(row)))
        occurrence = occurrences.get(identity,0)
        occurrences[identity] = occurrence+1
        if occurrence:
            identity += (("occurrence",occurrence),)
        row_columns = set()
        for index in value_positions:
            if index >= len(row) or _is_blank(row[index]):
                continue
            column = ANY_COLUMN if collapse else (names[index] if index < len(names) else f"col{index}")
            if column in row_columns:
                continue
            row_columns.add(column)
            key = (identity, column)
            cells[key] = str(row[index])
    return cells


def _row_cell_matches(predictions, golds, rel_tol, abs_tol):
    edges = [[index for index,(candidate_column,candidate) in enumerate(predictions) if (column == candidate_column or ANY_COLUMN in (column,candidate_column)) and values_match(candidate,value,rel_tol=rel_tol,abs_tol=abs_tol)] for column,value in golds]
    assigned = {}

    def match(gold, seen):
        for candidate in edges[gold]:
            if candidate in seen:
                continue
            seen.add(candidate)
            if candidate not in assigned or match(assigned[candidate],seen):
                assigned[candidate] = gold
                return True
        return False

    return sum(match(gold,set()) for gold in range(len(edges)))


def _maximum_row_matches(weights):
    if not weights or not weights[0]:
        return 0
    width = max(len(weights),len(weights[0]))
    costs = [[-weights[row][column] if row < len(weights) and column < len(weights[row]) else 0 for column in range(width)] for row in range(width)]
    row_potential,column_potential,assigned,previous = [[0]*(width+1) for _ in range(4)]
    for row in range(1,width+1):
        assigned[0] = row
        column = 0
        distances,used = [float('inf')]*(width+1),[False]*(width+1)
        while True:
            used[column] = True
            current_row = assigned[column]
            delta,next_column = float('inf'),0
            for candidate in range(1,width+1):
                if used[candidate]:
                    continue
                cost = costs[current_row-1][candidate-1]-row_potential[current_row]-column_potential[candidate]
                if cost < distances[candidate]:
                    distances[candidate],previous[candidate] = cost,column
                if distances[candidate] < delta:
                    delta,next_column = distances[candidate],candidate
            for candidate in range(width+1):
                if used[candidate]:
                    row_potential[assigned[candidate]] += delta
                    column_potential[candidate] -= delta
                else:
                    distances[candidate] -= delta
            column = next_column
            if assigned[column] == 0:
                break
        while column:
            prior = previous[column]
            assigned[column] = assigned[prior]
            column = prior
    return -sum(costs[assigned[column]-1][column-1] for column in range(1,width+1))


def count_matches(pred_cells, gold_cells, rel_tol=1e-3, abs_tol=1e-6):
    def groups(cells):
        grouped = {}
        for (identity,column),value in cells.items():
            base = tuple(part for part in identity if not isinstance(part,tuple))
            grouped.setdefault(base,{}).setdefault(identity,[]).append((column,value))
        return grouped

    predictions,golds = groups(pred_cells),groups(gold_cells)
    total = 0
    for identity,rows in golds.items():
        candidates = list(predictions.get(identity,{}).values())
        weights = [[_row_cell_matches(candidate,row,rel_tol,abs_tol) for candidate in candidates] for row in rows.values()]
        total += _maximum_row_matches(weights)
    return total


def to_number(text):
    cleaned = text.strip().replace(",", "").replace("\u2212", "-").rstrip("%").strip()
    try:
        return float(cleaned)
    except ValueError:
        return None


def values_match(a, b, rel_tol=1e-3, abs_tol=1e-6):
    left, right = to_number(a), to_number(b)
    if left is not None and right is not None:
        return math.isclose(left, right, rel_tol=rel_tol, abs_tol=abs_tol)
    return a.strip().lower() == b.strip().lower()



import json
import time
from collections import defaultdict


STRICT_TOLERANCE = (1e-3, 1e-6)
TOLERANCE_LEVELS = {"tol3": 0.03, "tol5": 0.05}
SHARE_POINTS_SCALE = 100.0
SHARE_CHART_TYPES = {"treemap"}
HISTOGRAM_EDGE_TOKENS = ("start", "end")


def _norm(value):
    return value.strip().lower() if isinstance(value, str) else value


def _present(value):
    if value is None:
        return False
    if isinstance(value, str):
        return value.strip() != ""
    return True


def _to_float(value):
    try:
        return float(value)
    except (TypeError, ValueError):
        return None


def _exact_eq(pred, gold):
    return pred == gold


def _text_eq(pred, gold):
    return _norm(pred) == _norm(gold)


def _num_eq(pred, gold):
    left, right = _to_float(pred), _to_float(gold)
    return left is not None and values_match(str(left), str(right))


def _mapping(target, key):
    value = target.get(key) if isinstance(target, dict) else None
    return value if isinstance(value, dict) else {}


def _axis(target, channel):
    axis = _mapping(target, "axes").get(channel)
    return axis if isinstance(axis, dict) else {}


def _value_representation(target, key):
    return _mapping(target, "valueRepresentation").get(key)


SCALAR_FIELDS = (
    ("type", lambda t: t.get("chartType"), _exact_eq),
    ("title", lambda t: t.get("title"), _text_eq),
    ("value_mode", lambda t: _value_representation(t, "mode"), _exact_eq),
    ("value_format", lambda t: _value_representation(t, "format"), _text_eq),
    ("x_label", lambda t: _axis(t, "x").get("label"), _text_eq),
    ("y_label", lambda t: _axis(t, "y").get("label"), _text_eq),
    ("z_label", lambda t: _axis(t, "z").get("label"), _text_eq),
    ("x_scale", lambda t: _axis(t, "x").get("scale"), _exact_eq),
    ("y_scale", lambda t: _axis(t, "y").get("scale"), _exact_eq),
    ("z_scale", lambda t: _axis(t, "z").get("scale"), _exact_eq),
    ("legend_visible", lambda t: _mapping(t, "legend").get("visible"), _exact_eq),
    ("datalabels_visible", lambda t: _mapping(t, "dataLabels").get("visible"), _exact_eq),
)


def _scalar_observe(getter, eq):
    def observe(pred, gold):
        gold_value, pred_value = getter(gold), getter(pred)
        gold_present, pred_present = _present(gold_value), _present(pred_value)
        correct = gold_present and pred_present and eq(pred_value, gold_value)
        return [(gold_present, pred_present, correct)]

    return observe


def _axis_names(pred, gold):
    return set(AXIS_CHANNELS) | set(_mapping(pred, "axes")) | set(_mapping(gold, "axes"))


def _observe_secondary_axis(attr, eq):
    def observe(pred, gold):
        observations = []
        for channel in sorted(_axis_names(pred,gold) - set(AXIS_CHANNELS)):
            gold_value,pred_value = _axis(gold,channel).get(attr),_axis(pred,channel).get(attr)
            gold_present,pred_present = _present(gold_value),_present(pred_value)
            observations.append((gold_present,pred_present,gold_present and pred_present and eq(pred_value,gold_value)))
        return observations

    return observe


def _observe_axis_bounds(pred, gold):
    observations = []
    for channel in sorted(_axis_names(pred,gold)):
        gold_axis, pred_axis = _axis(gold, channel), _axis(pred, channel)
        for key in ("min", "max"):
            gold_value, pred_value = gold_axis.get(key), pred_axis.get(key)
            gold_present, pred_present = gold_value is not None, pred_value is not None
            correct = gold_present and pred_present and _num_eq(pred_value, gold_value)
            observations.append((gold_present, pred_present, correct))
    return observations


def _row_width(row):
    return len(row) if isinstance(row, (list, tuple)) else -1


def _columns_by_name(target):
    data = _data(target)
    source = data.get("columns")
    columns = {}
    for column in source if isinstance(source, list) else []:
        if isinstance(column, dict) and column.get("name") is not None:
            columns[_norm(column["name"])] = column
    return columns


def _observe_column_attr(attr, eq):
    def observe(pred, gold):
        gold_columns, pred_columns = _columns_by_name(gold), _columns_by_name(pred)
        observations = []
        for name, gold_column in gold_columns.items():
            gold_value = gold_column.get(attr)
            pred_column = pred_columns.get(name)
            pred_value = pred_column.get(attr) if pred_column else None
            gold_present, pred_present = _present(gold_value), _present(pred_value)
            correct = gold_present and pred_present and eq(pred_value, gold_value)
            observations.append((gold_present, pred_present, correct))
        return observations

    return observe


OBSERVATION_FIELDS = (
    tuple((key, _scalar_observe(getter, eq)) for key, getter, eq in SCALAR_FIELDS)
    + (
        ("axis_bound", _observe_axis_bounds),
        ("secondary_axis_label", _observe_secondary_axis("label", _text_eq)),
        ("secondary_axis_scale", _observe_secondary_axis("scale", _exact_eq)),
        ("column_type", _observe_column_attr("type", _exact_eq)),
        ("column_role", _observe_column_attr("role", _exact_eq)),
        ("column_unit", _observe_column_attr("unit", _text_eq)),
    )
)


def _key(value):
    if isinstance(value, str):
        return _norm(value)
    if value is None or isinstance(value, (int, float, bool)):
        return value
    return str(value)


def _encoding_pairs(target):
    encoding = target.get("encoding")
    if not isinstance(encoding, dict):
        return set()
    return {(str(channel), _key(field)) for channel, field in encoding.items() if _present(field)}


def _series_pairs(target):
    series = target.get("series")
    if not isinstance(series, list):
        return set()
    pairs = set()
    for entry in series:
        if isinstance(entry, dict):
            pairs.add((_key(entry.get("name")), _key(entry.get("field"))))
    return pairs


def _series_axis_pairs(target):
    series = target.get("series") if isinstance(target, dict) else None
    if not isinstance(series, list):
        return set()
    return {(_key(entry.get('field')), _key(entry['axis'])) for entry in series if isinstance(entry, dict) and entry.get('axis')}


SET_FIELDS = (
    ("encoding", _encoding_pairs),
    ("series", _series_pairs),
    ("series_axis", _series_axis_pairs),
)


def _data(target):
    data = target.get("data") if isinstance(target, dict) else None
    return data if isinstance(data, dict) else {"columns": [], "rows": []}


def _value_range(gold):
    data = _data(gold)
    columns = data.get("columns", [])
    spatial = any(isinstance(column,dict) and column.get("role") == "z" for column in columns)
    positions = [index for index,column in enumerate(columns) if isinstance(column,dict) and column.get("role") in ("z","value")] if spatial else list(range(1,len(columns)))
    values = [to_number(str(row[index])) for row in data.get("rows", []) if isinstance(row, (list, tuple)) for index in positions if index < len(row)]
    values = [value for value in values if value is not None]
    if not values:
        return 1.0
    return (max(values) - min(values)) or max(abs(value) for value in values) or 1.0


def _stores_shares(gold):
    return _value_representation(gold, "mode") == "percentage_of_total" or gold.get("chartType") in SHARE_CHART_TYPES


def chart_tolerance(gold, fraction):
    if fraction is None or (gold.get("dataLabels") or {}).get("visible"):
        return STRICT_TOLERANCE
    if _stores_shares(gold):
        return (0.0, fraction * SHARE_POINTS_SCALE)
    return (0.0, fraction * _value_range(gold))


def _drop_histogram_edges(data):
    columns, rows = data.get("columns"), data.get("rows")
    if not isinstance(columns, list) or not isinstance(rows, list):
        return data
    keep = [i for i, column in enumerate(columns)
            if not (isinstance(column, dict) and any(token in str(column.get("name", "")).lower() for token in HISTOGRAM_EDGE_TOKENS))]
    if len(keep) == len(columns):
        return data
    trimmed_rows = [[row[i] for i in keep if i < len(row)] for row in rows if isinstance(row, (list, tuple))]
    return {**data, "columns": [columns[i] for i in keep], "rows": trimmed_rows}


def score_sample(pred, gold):
    pred_data, gold_data = _data(pred), _data(gold)
    if gold.get("chartType") == "histogram":
        pred_data, gold_data = _drop_histogram_edges(pred_data), _drop_histogram_edges(gold_data)
    pred_cells = data_cells(pred_data.get("columns", []), pred_data.get("rows", []))
    gold_cells = data_cells(gold_data.get("columns", []), gold_data.get("rows", []))
    tp = count_matches(pred_cells, gold_cells)
    tp_at = {
        level: count_matches(pred_cells, gold_cells, *chart_tolerance(gold, fraction))
        for level, fraction in TOLERANCE_LEVELS.items()
    }
    gold_rows = gold_data.get("rows") if isinstance(gold_data.get("rows"), list) else []
    pred_rows = pred_data.get("rows") if isinstance(pred_data.get("rows"), list) else []
    shape_match = float(
        len(pred_rows) == len(gold_rows)
        and [_row_width(r) for r in pred_rows] == [_row_width(r) for r in gold_rows]
    )
    fields = {key: observe(pred, gold) for key, observe in OBSERVATION_FIELDS}
    sets = {}
    for key, pairs in SET_FIELDS:
        gold_pairs, pred_pairs = pairs(gold), pairs(pred)
        matched = len(gold_pairs & pred_pairs)
        sets[key] = (matched, len(pred_pairs) - matched, len(gold_pairs) - matched)
    return {
        "tp": tp,
        "fp": len(pred_cells) - tp,
        "fn": len(gold_cells) - tp,
        "tp_at": tp_at,
        "shape_match": shape_match,
        "chart_type": gold.get("chartType", "unknown"),
        "fields": fields,
        "sets": sets,
    }


def precision_recall_f1(tp, fp, fn):
    precision = tp / (tp + fp) if (tp + fp) else 0.0
    recall = tp / (tp + fn) if (tp + fn) else 0.0
    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) else 0.0
    return precision, recall, f1


def chart_f1(row, level="strict"):
    tp = row["tp"] if level == "strict" else row["tp_at"][level]
    n_pred, n_gold = row["tp"] + row["fp"], row["tp"] + row["fn"]
    return precision_recall_f1(tp, n_pred - tp, n_gold - tp)[2]


def mean_chart_f1(rows, level="strict"):
    return sum(chart_f1(row, level) for row in rows) / len(rows) if rows else 0.0


def tolerant_means(rows, key="mean_chart_f1"):
    return {f"{key}_{level}": mean_chart_f1(rows, level) for level in TOLERANCE_LEVELS}


def aggregate_fields(rows):
    stats = {}
    for key, _ in OBSERVATION_FIELDS:
        acc_n = correct = halluc_n = halluc_hits = 0
        for row in rows:
            for gold_present, pred_present, is_correct in row["fields"][key]:
                if gold_present:
                    acc_n += 1
                    correct += int(is_correct)
                else:
                    halluc_n += 1
                    halluc_hits += int(pred_present)
        stats[key] = {
            "acc": correct / acc_n if acc_n else 0.0,
            "acc_n": acc_n,
            "halluc": halluc_hits / halluc_n if halluc_n else None,
            "halluc_n": halluc_n,
        }
    return stats


def aggregate_sets(rows):
    stats = {}
    for key, _ in SET_FIELDS:
        tp = sum(row["sets"][key][0] for row in rows)
        fp = sum(row["sets"][key][1] for row in rows)
        fn = sum(row["sets"][key][2] for row in rows)
        precision, recall, f1 = precision_recall_f1(tp, fp, fn)
        stats[key] = {"precision": precision, "recall": recall, "f1": f1, "tp": tp, "fp": fp, "fn": fn}
    return stats


def evaluate(dataset, predict, show=0):
    rows = []
    for i in range(len(dataset)):
        example = dataset[i]
        pred = extract_target(predict(example))
        gold = json.loads(example["target"]) if isinstance(example["target"], str) else example["target"]
        row = score_sample(pred, gold)
        rows.append(row)
        if i < show:
            print("=" * 80)
            print("id:", example.get("id"), "|", row["chart_type"], "|",
                  {k: row[k] for k in ("tp", "fp", "fn", "shape_match")})
            print("--- predicted ---")
            print(json.dumps(pred)[:600])
            print("--- ground truth ---")
            print(json.dumps(gold)[:600])
    shape_match = sum(r["shape_match"] for r in rows) / len(rows) if rows else 0.0
    return {
        "mean_chart_f1": mean_chart_f1(rows),
        **tolerant_means(rows),
        "shape_match": shape_match,
        "fields": aggregate_fields(rows),
        "sets": aggregate_sets(rows),
        "rows": rows,
    }


def scoring_view(dataset):
    if hasattr(dataset, "remove_columns") and hasattr(dataset, "column_names"):
        return dataset.remove_columns([column for column in dataset.column_names if column not in ("id", "target")])
    return dataset


def _target_lengths(dataset):
    if hasattr(dataset, "select_columns"):
        return [len(target) for target in dataset.select_columns(["target"])["target"]]
    return [len(example["target"]) for example in dataset]


def evaluate_batched(dataset, predict_batch, batch_size, show=0, log=print):
    lengths = _target_lengths(dataset)
    order = sorted(range(len(dataset)), key=lambda index: lengths[index])
    predictions = {}
    started = time.monotonic()
    for start in range(0, len(order), batch_size):
        batch = [dataset[index] for index in order[start:start + batch_size]]
        for example, text in zip(batch, predict_batch(batch)):
            predictions[example["id"]] = text
        done = start + len(batch)
        elapsed = time.monotonic() - started
        log(f"eval {done}/{len(order)} charts | {elapsed:.0f}s | {60 * done / max(elapsed, 1e-9):.1f} charts/min")
    return evaluate(scoring_view(dataset), lambda example: predictions[example["id"]], show=show)


def aggregate_by_chart_type(rows):
    groups = defaultdict(list)
    for row in rows:
        groups[row["chart_type"]].append(row)
    per_type = []
    for chart_type, group in sorted(groups.items(), key=lambda kv: -len(kv[1])):
        shape_match = sum(r["shape_match"] for r in group) / len(group)
        per_type.append(
            {
                "chart_type": chart_type,
                "n": len(group),
                "mean_chart_f1": mean_chart_f1(group),
                **tolerant_means(group),
                "shape_match": shape_match,
                "fields": aggregate_fields(group),
                "sets": aggregate_sets(group),
            }
        )
    return per_type


def macro_metrics(per_type):
    if not per_type:
        return {"macro_mean_chart_f1": 0.0}
    return {"macro_mean_chart_f1": sum(t["mean_chart_f1"] for t in per_type) / len(per_type)}


def _flatten_fields(prefix, metrics):
    flat = {}
    for key, stat in metrics["fields"].items():
        flat[f"{prefix}/{key}_acc"] = stat["acc"]
        if stat["halluc"] is not None:
            flat[f"{prefix}/{key}_halluc"] = stat["halluc"]
    for key, stat in metrics["sets"].items():
        flat[f"{prefix}/{key}_precision"] = stat["precision"]
        flat[f"{prefix}/{key}_recall"] = stat["recall"]
        flat[f"{prefix}/{key}_f1"] = stat["f1"]
    return flat


def scored_metrics(test_metrics, train_metrics, eval_prefix="test"):
    test_macro = macro_metrics(aggregate_by_chart_type(test_metrics["rows"]))
    train_macro = macro_metrics(aggregate_by_chart_type(train_metrics["rows"]))
    scored = {
        f"{eval_prefix}/mean_chart_f1": test_metrics["mean_chart_f1"],
        f"{eval_prefix}/shape_match": test_metrics["shape_match"],
        f"{eval_prefix}/macro_mean_chart_f1": test_macro["macro_mean_chart_f1"],
        "train/mean_chart_f1": train_metrics["mean_chart_f1"],
        "train/shape_match": train_metrics["shape_match"],
        "train/macro_mean_chart_f1": train_macro["macro_mean_chart_f1"],
        "overfitting/mean_chart_f1_gap": train_metrics["mean_chart_f1"] - test_metrics["mean_chart_f1"],
    }
    scored.update(_flatten_fields(eval_prefix, test_metrics))
    scored.update(_flatten_fields("train", train_metrics))
    return scored



def summary_row(name, metrics):
    fields, sets = metrics["fields"], metrics["sets"]
    return {
        "model": name,
        "n": len(metrics["rows"]),
        "mean_f1": metrics["mean_chart_f1"],
        "mean_f1_tol3": metrics["mean_chart_f1_tol3"],
        "mean_f1_tol5": metrics["mean_chart_f1_tol5"],
        "shape": metrics["shape_match"],
        "type_acc": fields["type"]["acc"],
        "title_acc": fields["title"]["acc"],
        "encoding_f1": sets["encoding"]["f1"],
        "series_f1": sets["series"]["f1"],
    }

import hashlib
import io
from PIL import Image
MAX_IMAGE_PIXELS = 602112
BENCHMARK_PROMPT = "Extract a chart image's structure and data as JSON. Return ONLY a JSON object with keys: title, chartType, data, valueRepresentation, encoding, axes, series, legend, dataLabels.\nchartType: bar, line, area, pie, scatter, bubble, histogram, box, violin, heatmap, treemap, funnel, radar, candlestick, step, stem, combo. title: text or null.\ndata: {columns:[{name, type(categorical|numeric|temporal), role(category|value|series|x|y|z|size|color), unit}], rows:[[...]]}.\nvalueRepresentation:{mode(absolute|percentage_of_total), format('0.0%','integer', null)}. encoding: column per used channel of x, y, y2, z, z2, color, size, category, value.\naxes:{x:{label, unit, scale(categorical|linear|logarithmic|temporal), min, max}, y:{...}, z:{...} for 3D, x2/y2:{...} for extra axes} or null for pie/sunburst/treemap/funnel/radar/rose; min/max are visible limits. series:[{name, field, axis?}]. legend:{visible, position, entries}. dataLabels:{visible, format}.\nUse visible data; null where unsupported. Pie, donut, treemap, and 100%-stacked charts use 'percentage_of_total'; others use 'absolute'. Keep visible limits and repeated observations. Floating bars use Start and End columns. 3D: keep x/y/z; floating bars encode upper/lower endpoints as z/z2 or y/y2.\nExtract this chart's structured data."
SCORER_HASH = '1782c0b90274e10082385f219e7fbc73e7e7bb2dc4eec02b59480519f72c52de'
def digest(value):
    return hashlib.sha256(value).hexdigest()

def canonical_hash(value):
    return digest(json.dumps(value, sort_keys=True, ensure_ascii=False, allow_nan=False, separators=(',', ':')).encode())

def image_hash(image):
    if isinstance(image, dict):
        image = Image.open(io.BytesIO(image['bytes'])) if image.get('bytes') else Image.open(image['path'])
    elif isinstance(image, bytes):
        image = Image.open(io.BytesIO(image))
    rgb = image.convert('RGB')
    return digest(str(rgb.size).encode() + rgb.tobytes())

def input_hash(image, prompt):
    return canonical_hash({'image': image_hash(image), 'max_pixels': MAX_IMAGE_PIXELS, 'prompt': prompt})



def _load_predictions(path):
    predictions = {}
    with open(path, encoding="utf-8") as handle:
        for line in handle:
            if line.strip():
                record = json.loads(line)
                predictions[record["id"]] = record
    return predictions


def main():
    parser = argparse.ArgumentParser(description="Score chart-parsing predictions against the frozen benchmark.")
    parser.add_argument("--benchmark-repo", default="nutrientdocs/chart-parsing-benchmark")
    parser.add_argument("--predictions", required=True, help="JSONL of {id, text, input_hash} records")
    parser.add_argument("--revision", default=None)
    parser.add_argument("--out", required=True)
    parser.add_argument("--name", required=True, help="entry name shown on the leaderboard")
    parser.add_argument("--token", default=None)
    args = parser.parse_args()

    from datasets import load_dataset

    from huggingface_hub import hf_hub_download

    benchmark = load_dataset(args.benchmark_repo, revision=args.revision, split="test", token=args.token)
    meta_path = hf_hub_download(args.benchmark_repo, "benchmark_meta.json", repo_type="dataset", revision=args.revision, token=args.token)
    with open(meta_path) as handle:
        meta = json.load(handle)
    predictions = _load_predictions(args.predictions)
    for example in benchmark:
        prediction = predictions.get(example["id"])
        if prediction is not None and prediction.get("input_hash") != input_hash(example["image"], BENCHMARK_PROMPT):
            raise ValueError(f"Prediction input differs for {example['id']}; generate it again")
    missing = [identifier for identifier in benchmark["id"] if identifier not in predictions]
    metrics = evaluate(benchmark, lambda example: predictions.get(example["id"], {}).get("text", ""))
    result = {
        "summary": summary_row(args.name, metrics),
        "per_chart_type": aggregate_by_chart_type(metrics["rows"]),
        "fields": metrics["fields"],
        "sets": metrics["sets"],
        "missing_predictions": len(missing),
        "benchmark_version": meta["version"],
        "benchmark_content_hash": meta.get("content_hash"),
        "scorer_hash": SCORER_HASH,
    }
    with open(args.out, "w", encoding="utf-8") as handle:
        json.dump(result, handle, indent=2)
    row = result["summary"]
    print(
        f"{args.name}: mean_f1 {row['mean_f1']:.3f} | tol3 {row['mean_f1_tol3']:.3f} "
        f"| tol5 {row['mean_f1_tol5']:.3f} | shape {row['shape']:.3f} | missing {len(missing)}"
    )


if __name__ == "__main__":
    main()