| """Core normalization logic for Nebius SWE-rebench OpenHands trajectories. |
| |
| The upstream parquet stores ``tool_call.function.arguments`` as a *serialized |
| JSON string*. Chat templates (e.g. Qwen3-Coder) iterate ``arguments|items`` and |
| therefore require a mapping -- feeding the raw string produces empty or broken |
| tool calls at train/infer time. This module deserializes arguments, canonicalizes |
| message fields per role, and optionally validates tool calls against the |
| upstream ``tools.json``. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import ast |
| import json |
| from dataclasses import dataclass, field |
| from typing import Any, Iterable, Optional |
|
|
| |
| ROLE_FIELDS = { |
| "system": ("role", "content"), |
| "user": ("role", "content"), |
| "assistant": ("role", "content", "tool_calls"), |
| "tool": ("role", "content", "name", "tool_call_id"), |
| } |
| KNOWN_ROLES = frozenset(ROLE_FIELDS) |
|
|
|
|
| @dataclass |
| class Stats: |
| """Accumulates fix/drop counters; serialized into meta.json.""" |
|
|
| input_rows: int = 0 |
| resolved_rows: int = 0 |
| written_success: int = 0 |
| written_fail: int = 0 |
| skipped_unresolved: int = 0 |
| drop_reasons: dict = field(default_factory=dict) |
| fixes: dict = field(default_factory=dict) |
| unknown_tools: dict = field(default_factory=dict) |
| missing_required_params: dict = field(default_factory=dict) |
| unparseable_examples: list = field(default_factory=list) |
|
|
| def bump(self, bucket: dict, key: str, n: int = 1) -> None: |
| bucket[key] = bucket.get(key, 0) + n |
|
|
| def drop(self, reason: str) -> None: |
| self.bump(self.drop_reasons, reason) |
|
|
| def fix(self, kind: str, n: int = 1) -> None: |
| self.bump(self.fixes, kind, n) |
|
|
|
|
| def load_tools_schema(path: Optional[str]) -> Optional[dict]: |
| """Load an OpenAI-style tools.json -> {name: {required: set, properties: set}}.""" |
| if not path: |
| return None |
| with open(path) as f: |
| tools = json.load(f) |
| schema = {} |
| for entry in tools: |
| fn = entry.get("function", entry) |
| name = fn.get("name") |
| if not name: |
| continue |
| params = fn.get("parameters") or {} |
| schema[name] = { |
| "required": set(params.get("required") or []), |
| "properties": set((params.get("properties") or {}).keys()), |
| } |
| return schema |
|
|
|
|
| def deserialize_arguments(raw: Any, stats: Stats) -> tuple[Optional[dict], Optional[str]]: |
| """Return (arguments_dict, drop_reason). arguments_dict is None on failure.""" |
| if raw is None: |
| stats.fix("missing_arguments") |
| return {}, None |
| if isinstance(raw, dict): |
| return raw, None |
| if not isinstance(raw, str): |
| return None, "arguments_not_object" |
|
|
| value: Any = raw |
| rounds = 0 |
| while isinstance(value, str): |
| rounds += 1 |
| if rounds > 3: |
| return None, "arguments_unparseable" |
| try: |
| value = json.loads(value) |
| except (json.JSONDecodeError, ValueError): |
| try: |
| value = ast.literal_eval(value) |
| stats.fix("literal_eval_fallback") |
| except (ValueError, SyntaxError, MemoryError): |
| snippet = value[:200] if isinstance(value, str) else repr(value)[:200] |
| if len(stats.unparseable_examples) < 5: |
| stats.unparseable_examples.append(snippet) |
| return None, "arguments_unparseable" |
| if rounds > 1: |
| stats.fix("double_encoded_arguments") |
| stats.fix("arguments_deserialized") |
| if not isinstance(value, dict): |
| return None, "arguments_not_object" |
| return value, None |
|
|
|
|
| def normalize_tool_call(tc: Any, stats: Stats) -> tuple[Optional[dict], Optional[str]]: |
| """Normalize one tool call to {"id"?, "type"?, "function": {"name", "arguments": dict}}.""" |
| if not isinstance(tc, dict): |
| return None, "tool_call_not_object" |
|
|
| |
| fn = tc.get("function") if isinstance(tc.get("function"), dict) else None |
| if fn is None: |
| if "name" in tc or "arguments" in tc: |
| fn = {"name": tc.get("name"), "arguments": tc.get("arguments")} |
| stats.fix("flattened_tool_call") |
| else: |
| return None, "tool_call_missing_function" |
|
|
| args, err = deserialize_arguments(fn.get("arguments"), stats) |
| if err: |
| return None, err |
|
|
| out = {"type": tc.get("type", "function"), |
| "function": {"name": fn.get("name"), "arguments": args}} |
| if tc.get("id") is not None: |
| out["id"] = tc["id"] |
| return out, None |
|
|
|
|
| def normalize_message(msg: Any, stats: Stats) -> tuple[Optional[dict], Optional[str]]: |
| if not isinstance(msg, dict): |
| return None, "message_not_object" |
| role = msg.get("role") |
| if role not in KNOWN_ROLES: |
| return None, f"unknown_role:{role}" |
|
|
| out = {k: msg.get(k) for k in ROLE_FIELDS[role] if msg.get(k) is not None or k in ("role", "content")} |
|
|
| if role == "assistant": |
| tcs = msg.get("tool_calls") |
| if tcs: |
| norm = [] |
| for tc in tcs: |
| ntc, err = normalize_tool_call(tc, stats) |
| if err: |
| return None, err |
| norm.append(ntc) |
| out["tool_calls"] = norm |
| else: |
| out.pop("tool_calls", None) |
| return out, None |
|
|
|
|
| def validate_against_tools(messages: Iterable[dict], schema: dict, stats: Stats) -> int: |
| """Soft validation: count tool calls whose name or required params are off. |
| |
| Returns the number of calls in *these* messages using an unknown tool name. |
| """ |
| unknown = 0 |
| for msg in messages: |
| if msg.get("role") != "assistant": |
| continue |
| for tc in msg.get("tool_calls") or []: |
| fn = tc.get("function", {}) |
| name = fn.get("name") |
| spec = schema.get(name) |
| if spec is None: |
| stats.bump(stats.unknown_tools, str(name)) |
| unknown += 1 |
| continue |
| missing = spec["required"] - set((fn.get("arguments") or {}).keys()) |
| for p in missing: |
| stats.bump(stats.missing_required_params, f"{name}:{p}") |
| return unknown |
|
|
|
|
| def normalize_row(row: dict, stats: Stats, tools_schema: Optional[dict] = None, |
| strict_tools: bool = False) -> tuple[Optional[list], Optional[str]]: |
| """Normalize one parquet row -> messages list, or (None, drop_reason).""" |
| traj = row.get("trajectory") |
| if not traj: |
| return None, "empty_trajectory" |
|
|
| messages = [] |
| for msg in traj: |
| nm, err = normalize_message(msg, stats) |
| if err: |
| return None, err |
| messages.append(nm) |
|
|
| if not any(m["role"] == "assistant" for m in messages): |
| return None, "no_assistant_messages" |
|
|
| if tools_schema: |
| n_unknown = validate_against_tools(messages, tools_schema, stats) |
| if strict_tools and n_unknown: |
| return None, "unknown_tool" |
|
|
| return messages, None |
|
|
|
|
| def row_to_record(row: dict, messages: list, emit_tools: bool = True) -> dict: |
| rec = { |
| "messages": messages, |
| "trajectory_id": row.get("trajectory_id"), |
| "instance_id": row.get("instance_id"), |
| "repo": row.get("repo"), |
| "resolved": int(row.get("resolved") or 0), |
| "exit_status": row.get("exit_status"), |
| "model_patch": row.get("model_patch"), |
| "gen_tests_correct": row.get("gen_tests_correct"), |
| "pred_passes_gen_tests": row.get("pred_passes_gen_tests"), |
| } |
| if emit_tools and row.get("tools"): |
| rec["tools"] = row["tools"] |
| return rec |
|
|
