"""Shared helpers for building the Bloxy training set.""" from __future__ import annotations import hashlib import json import random import re from pathlib import Path from typing import Iterable, Iterator SYSTEM_PROMPT = ( "You are Bloxy, an AI that builds and scripts in Roblox Studio. " "You are best at building: you turn a description into a clean, anchored, " "well-proportioned build made of Parts. Scale: 1 stud is 1 unit, a character " "is about 5 studs tall, a door is about 7 studs tall, a floor is about 12 studs " "high. You write correct, modern Luau, use Studio tools carefully when they are " "available, and keep answers short." ) # Rough characters-per-token for Gemma's tokenizer on code/English mixes. # Only used for budgeting; the trainer filters by real token counts. CHARS_PER_TOKEN = 3.3 _FENCE = re.compile(r"```.*?```", re.DOTALL) def est_tokens(messages: list[dict]) -> int: """Conservative token estimate. Code (numbers, punctuation) packs ~2.4 chars per Gemma token, prose ~3.6; checked against the real tokenizer in check_format.py.""" code = prose = 0 for m in messages: c = m.get("content") or "" blocks = sum(len(b) for b in _FENCE.findall(c)) code += blocks prose += len(c) - blocks for tc in m.get("tool_calls") or []: code += len(json.dumps(tc.get("function", {}), ensure_ascii=False)) return int(code / 2.1 + prose / 3.6) + 8 * len(messages) def chat(user: str, assistant: str, system: str = SYSTEM_PROMPT) -> list[dict]: return [ {"role": "system", "content": system}, {"role": "user", "content": user.strip()}, {"role": "assistant", "content": assistant.strip()}, ] THINK_RE = re.compile(r".*?\s*", re.DOTALL) def strip_think(text: str) -> str: return THINK_RE.sub("", text or "").strip() def norm_for_hash(text: str) -> str: return re.sub(r"\s+", " ", (text or "").lower()).strip() def example_key(messages: list[dict]) -> str: """Dedup key: last user message + last assistant answer (normalized).""" users = [m for m in messages if m["role"] == "user"] asst = [m for m in messages if m["role"] == "assistant" and m.get("content")] u = norm_for_hash(users[-1]["content"])[:2000] if users else "" a = norm_for_hash(asst[-1]["content"])[:4000] if asst else "" return hashlib.sha1((u + "\x00" + a).encode()).hexdigest() def answer_key(messages: list[dict]) -> str: """Near-dup key on the answer only (catches the same code under new prompts).""" asst = [m for m in messages if m["role"] == "assistant" and m.get("content")] a = norm_for_hash(asst[-1]["content"]) if asst else "" return hashlib.sha1(a.encode()).hexdigest() def reservoir(items: Iterable, k: int, rng: random.Random) -> list: out: list = [] for i, it in enumerate(items): if i < k: out.append(it) else: j = rng.randint(0, i) if j < k: out[j] = it return out def write_jsonl(path: Path, rows: Iterable[dict]) -> int: path.parent.mkdir(parents=True, exist_ok=True) n = 0 opener = open if str(path).endswith(".gz"): import gzip opener = gzip.open # type: ignore[assignment] with opener(path, "wt", encoding="utf-8") as f: # type: ignore[call-arg] for r in rows: f.write(json.dumps(r, ensure_ascii=False) + "\n") n += 1 return n def read_jsonl(path: Path) -> Iterator[dict]: opener = open if str(path).endswith(".gz"): import gzip opener = gzip.open # type: ignore[assignment] with opener(path, "rt", encoding="utf-8") as f: # type: ignore[call-arg] for line in f: if line.strip(): yield json.loads(line) LUA_BLOCK = re.compile(r"```lua\n(.*?)```", re.DOTALL) def luau_compiles(messages: list[dict], compiler: str) -> bool: """True if every ```lua block in the assistant turns compiles with luau-compile.""" import subprocess import tempfile for m in messages: if m.get("role") != "assistant": continue for code in LUA_BLOCK.findall(m.get("content") or ""): with tempfile.NamedTemporaryFile("w", suffix=".luau", delete=False) as f: f.write(code) r = subprocess.run([compiler, "--null", f.name], capture_output=True) Path(f.name).unlink(missing_ok=True) if r.returncode != 0: return False return True def pretty_name(slug: str) -> str: s = re.sub(r"[-_]+", " ", slug or "").strip() s = re.sub(r"\s+\d+$", "", s) # drop trailing variant numbers: "house 2" s = re.sub(r"\s+", " ", s) return s def pascal(name: str) -> str: parts = re.findall(r"[A-Za-z0-9]+", name) out = "".join(p[:1].upper() + p[1:] for p in parts) or "Build" if out[0].isdigit(): out = "Build" + out return out[:40]