Eval: inline helpers (no cross-script import)

eval_securecoder.py

@@ -76,7 +76,7 @@ def parse_args() -> argparse.Namespace:
     p.add_argument("--max-new-tokens", type=int, default=384)
     p.add_argument("--seed", type=int, default=3407)
     return p.parse_args()
-
+
 def _fetch_first_rows(repo: str, config: str | None, split: str, n: int) -> list[dict]:
     from datasets import load_dataset
 
@@ -87,13 +87,97 @@ def _fetch_first_rows(repo: str, config: str | None, split: str, n: int) -> list
     out = []
     for row in ds:
         out.append(dict(row))
+
+
+# --------------------------------------------------------------------------
+# Local helpers (inlined so the script runs standalone on HF Jobs without
+# needing train_securecoder.py to also be uploaded).
+# --------------------------------------------------------------------------
+_TYPE_ALIASES = {
+    "str": "string", "string": "string", "text": "string",
+    "int": "integer", "integer": "integer", "long": "integer",
+    "float": "number", "double": "number", "number": "number",
+    "bool": "boolean", "boolean": "boolean",
+    "list": "array", "array": "array", "dict": "object", "object": "object",
+}
+
+
+def _normalise_tool_schema_local(tool: Any) -> dict | None:
+    if not isinstance(tool, dict):
+        return None
+    fn = tool.get("function") if isinstance(tool.get("function"), dict) else tool
+    if not isinstance(fn, dict) or not fn.get("name"):
+        return None
+    params = fn.get("parameters") or {}
+    if isinstance(params, dict) and params and "properties" not in params:
+        properties: dict[str, Any] = {}
+        required: list[str] = []
+        for name, spec in params.items():
+            if isinstance(spec, dict):
+                cleaned = {k: v for k, v in spec.items()
+                           if k in ("type", "description", "enum", "default", "title", "items")}
+                cleaned["type"] = _TYPE_ALIASES.get(
+                    str(cleaned.get("type", "")).lower(), "string")
+                properties[name] = cleaned
+                if "default" not in spec:
+                    required.append(name)
+            else:
+                properties[name] = {"type": "string"}
+                required.append(name)
+        params = {"type": "object", "properties": properties}
+        if required:
+            params["required"] = required
+    return {"name": fn["name"], "description": fn.get("description", ""), "parameters": params}
+
+
+def _messages_from_any_local(row: dict, kind: str) -> tuple[list[dict], list[dict]]:
+    tools: list[dict] = []
+    raw = row.get("tools")
+    candidates = [raw] if isinstance(raw, dict) else (raw if isinstance(raw, list) else [])
+    for c in candidates:
+        n = _normalise_tool_schema_local(c)
+        if n:
+            tools.append(n)
+
+    messages: list[dict] = []
+    if isinstance(row.get("messages"), list):
+        for turn in row["messages"]:
+            if not isinstance(turn, dict):
+                continue
+            role = turn.get("role")
+            content = turn.get("content", "")
+            if role in {"user", "assistant", "system"} and content:
+                messages.append({"role": role, "content": str(content)})
+        return messages, tools
+
+    if row.get("query") and row.get("answers"):
+        messages.append({"role": "user", "content": str(row["query"])})
+        messages.append({"role": "assistant", "content": str(row["answers"])})
+        return messages, tools
+
+    if row.get("user") and row.get("assistant"):
+        if row.get("system"):
+            messages.append({"role": "system", "content": str(row["system"])})
+        messages.append({"role": "user", "content": str(row["user"])})
+        messages.append({"role": "assistant", "content": str(row["assistant"])})
+        return messages, tools
+
+    if row.get("instruction") and (row.get("output") or row.get("response")):
+        messages.append({"role": "user", "content": str(row["instruction"])})
+        messages.append({"role": "assistant", "content": str(row.get("output") or row.get("response"))})
+        return messages, tools
+
+    return [], tools
+
+
+
         if len(out) >= n:
             break
     return out
 
 
 def _build_tool_prompts(rows: list[dict]) -> list[dict]:
-    from train_securecoder import _normalise_tool_schema, _messages_from_any
+
 
     prompts = []
     for row in rows:
@@ -105,16 +189,16 @@ def _build_tool_prompts(rows: list[dict]) -> list[dict]:
         tools = []
         if isinstance(tools_raw, list):
             for t in tools_raw:
-                n = _normalise_tool_schema(t)
+                n = _normalise_tool_schema_local(t)
                 if n:
                     tools.append(n)
         elif isinstance(tools_raw, dict):
-            n = _normalise_tool_schema(tools_raw)
+            n = _normalise_tool_schema_local(tools_raw)
             if n:
                 tools.append(n)
         if not tools:
             continue
-        messages, _ = _messages_from_any(row, "auto")
+        messages, _ = _messages_from_any_local(row, "auto")
         if not messages:
             continue
         user = next((m["content"] for m in messages if m["role"] == "user"), None)
@@ -161,7 +245,7 @@ def _score_call(call: dict, tools: list[dict]) -> dict:
     return {"parse": True, "name_ok": True,
             "schema_ok": expected.issubset(given) if expected else True,
             "expected_keys": sorted(expected), "given_keys": sorted(given)}
-
+
 def eval_tool_calls(tokenizer, model, args) -> dict:
     import torch
 
@@ -260,7 +344,7 @@ def eval_code_sanity(tokenizer, model, args) -> dict:
     return {"section": "code_sanity", "n_prompts": n,
             "ast_rate": ast_ok / max(n, 1), "compile_rate": compile_ok / max(n, 1),
             "details": out}
-
+
 def eval_security_mcq(tokenizer, model, n_questions: int = 25) -> dict:
     import torch