bloxy-data-v1 / code /bloxy_data /sources.py
Radinkazemian's picture
Update Bloxy training code
e5d809c verified
Raw History Blame Contribute Delete
30.9 kB
"""One converter per Hugging Face dataset -> chat examples.
Every converter yields lists of chat messages (system/user/assistant[/tool]).
Data is read from the Hub's auto-converted Parquet files (refs/convert/parquet),
so every dataset loads the same way no matter how it was uploaded.
"""
from __future__ import annotations
import json
import random
import re
from collections import Counter
from typing import Iterator
from .common import SYSTEM_PROMPT, chat, est_tokens, pretty_name, strip_think
from . import minecraft, procedural
MAX_TOKENS = 3900 # leave room under the 4096 training context
# --------------------------------------------------------------- hub access
_hf_cache: dict = {}
def parquet_files(repo: str, config: str, split: str) -> list[str]:
from huggingface_hub import HfApi
key = repo
if key not in _hf_cache:
_hf_cache[key] = HfApi().list_repo_files(repo, repo_type="dataset", revision="refs/convert/parquet")
prefix = f"{config}/{split}/"
files = sorted(f for f in _hf_cache[key] if f.startswith(prefix) and f.endswith(".parquet"))
if not files: # older layout: config/<repo>-<split>.parquet
files = sorted(f for f in _hf_cache[key] if f.startswith(f"{config}/") and f"-{split}" in f and f.endswith(".parquet"))
if not files:
raise FileNotFoundError(f"no parquet for {repo} {config}/{split}")
return files
def iter_rows(repo: str, config: str = "default", split: str = "train", columns=None,
batch_size: int = 128) -> Iterator[dict]:
import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download
for f in parquet_files(repo, config, split):
path = hf_hub_download(repo, f, repo_type="dataset", revision="refs/convert/parquet")
pf = pq.ParquetFile(path)
cols = [c for c in columns if c in pf.schema_arrow.names] if columns else None
for batch in pf.iter_batches(batch_size=batch_size, columns=cols):
yield from batch.to_pylist()
def load_table(repo: str, config: str = "default", split: str = "train", columns=None):
import pyarrow as pa
import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download
tables = []
for f in parquet_files(repo, config, split):
path = hf_hub_download(repo, f, repo_type="dataset", revision="refs/convert/parquet")
tables.append(pq.read_table(path, columns=columns))
return pa.concat_tables(tables)
def _fits(msgs, limit: int = MAX_TOKENS) -> bool:
return est_tokens(msgs) <= limit
BUILD_LIMIT = 3500 # builds are number-heavy; keep a margin under the 4096 context
def _code_block(text: str, lang: str = "lua") -> str:
t = (text or "").strip()
if "```" in t:
return t
return f"```{lang}\n{t}\n```"
def _trim(text: str, limit: int) -> str:
text = (text or "").strip()
if len(text) <= limit:
return text
cut = text[:limit]
p = cut.rfind("\n\n")
return (cut[:p] if p > limit * 0.6 else cut).rstrip() + "\n..."
# --------------------------------------------------------------- building
def minecraft_builds(target: int, rng: random.Random, log, max_parts: int = 100):
"""mattismegevand/minecraft_builds: one row per block, grouped by structure."""
tbl = load_table("mattismegevand/minecraft_builds", columns=["x", "y", "z", "mat", "structure"])
df = tbl.to_pandas()
df["structure"] = df["structure"].astype("category")
df["mat"] = df["mat"].astype("category")
counts = df["structure"].value_counts()
cands = [s for s, c in counts.items() if 25 <= c <= 9000]
log(f" {len(counts)} structures, {len(cands)} in size range")
rng.shuffle(cands)
groups = df.groupby("structure", observed=True).indices
xs, ys, zs, mats = df["x"].to_numpy(), df["y"].to_numpy(), df["z"].to_numpy(), df["mat"].astype(str).to_numpy()
reasons: Counter = Counter()
accepted = []
for s in cands:
if len(accepted) >= target:
break
idx = groups[s]
blocks = [(int(xs[i]), int(ys[i]), int(zs[i]), mats[i]) for i in idx]
ex, why = minecraft.make_example(str(s), blocks, rng, max_parts)
if ex is None:
reasons[str(why)] += 1
continue
msgs = chat(*ex)
if not _fits(msgs, BUILD_LIMIT):
reasons["too many tokens"] += 1
continue
accepted.append((str(s), blocks))
yield msgs
log(f" accepted {len(accepted)}; rejected: {dict(reasons.most_common(6))}")
# top up with rotated copies (same build facing another way) if short: up to 2 per build
made = len(accepted)
for rot_pass in (0, 1):
for s, blocks in accepted:
if made >= target:
return
rot = [1, 3][rot_pass] if rng.random() < 0.5 else [3, 2][rot_pass]
ex, _ = minecraft.make_example(s, blocks, rng, max_parts, rotate=rot)
if ex and _fits(chat(*ex), BUILD_LIMIT):
made += 1
yield chat(*ex)
BLOCK_RE = re.compile(r"\(\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*['\"]?([\w:. ]+?)['\"]?\s*\)")
DESC_PREFIX = re.compile(r"^(the|this) (image|picture|screenshot|render)( (shows|depicts|features|displays|is of))?\s*", re.I)
def minecraftbuildings(target: int, rng: random.Random, log, max_parts: int = 100):
"""assskelad/minecraftbuildings: Description + '(x, y, z, id)' tuples (legacy ids)."""
rows = list(iter_rows("assskelad/minecraftbuildings", columns=["Description", "Block Info"], batch_size=32))
rng.shuffle(rows)
reasons: Counter = Counter()
n = 0
for r in rows:
if n >= target:
break
raw = r.get("Block Info") or ""
blocks = []
for m in BLOCK_RE.finditer(raw):
name = minecraft.legacy_name(m.group(4))
if name:
blocks.append((int(m.group(1)), int(m.group(2)), int(m.group(3)), name))
if len(blocks) < 25 or len(blocks) > 12000:
reasons["size"] += 1
continue
desc = DESC_PREFIX.sub("", (r.get("Description") or "").strip())
desc = re.split(r"(?<=[.!?])\s", desc)
desc = " ".join(desc[:3])[:500].strip()
if len(desc) < 20:
reasons["no desc"] += 1
continue
user = rng.choice(["Build this in Roblox: ", "Recreate this build with parts: ", "Build: "]) + desc[:1].lower() + desc[1:]
ex, why = minecraft.make_example("minecraft build", blocks, rng, max_parts, desc=user)
if ex is None:
reasons[str(why)] += 1
continue
u, a = ex
a = a.replace("minecraft build", "build").replace("Minecraft build", "Build")
msgs = chat(u, a)
if _fits(msgs, BUILD_LIMIT):
n += 1
yield msgs
log(f" rejected: {dict(reasons.most_common(6))}")
def procedural_builds(target: int, rng: random.Random, log):
kinds: Counter = Counter()
for kind, (u, a) in procedural.generate(target, seed=rng.randint(0, 10**9)):
kinds[kind] += 1
yield chat(u, a)
log(f" kinds: {dict(kinds)}")
def _strip_py_comments(code: str) -> str:
out = []
for line in code.splitlines():
s = line.strip()
if not s or s.startswith("#"):
continue
out.append(line.rstrip())
return "\n".join(out)
def blender_3dcode(target: int, rng: random.Random, log, max_chars: int = 10000):
rows = []
total = 0
for r in iter_rows("YipengGao/3DCode", config="3DCodeData",
columns=["caption_object", "caption_create_3D_object", "code"], batch_size=64):
total += 1
code = _strip_py_comments(r.get("code") or "")
if 300 < len(code) <= max_chars:
rows.append((r, code))
log(f" {len(rows)}/{total} scripts short enough (<= {max_chars} chars)")
rng.shuffle(rows)
for r, code in rows[:target]:
what = (r.get("caption_object") or "").strip()
user = r.get("caption_create_3D_object") or f"Write Blender Python code that creates {what}"
intro = "Here's a Blender (bpy) script that builds it procedurally. Run it in Blender's Scripting tab; you can export the mesh as .fbx and import it into Roblox Studio."
msgs = chat(user, f"{intro}\n\n```python\n{code}\n```")
if _fits(msgs):
yield msgs
def cadquery_code(target: int, rng: random.Random, log):
rows = list(iter_rows("ThomasTheMaker/TextToCadQuery-2", columns=["input", "output"], batch_size=512))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
inp, out = (r.get("input") or "").strip(), (r.get("output") or "").strip()
if len(inp) < 40 or "cadquery" not in out.lower() or len(inp) + len(out) > 7000:
continue
msgs = chat(f"{inp}\n\nWrite it as a CadQuery (Python) script.", _code_block(out, "python"))
n += 1
yield msgs
def cadquery_plans(target: int, rng: random.Random, log):
rows = []
for r in iter_rows("ThomasTheMaker/TextToCadQuery-1", columns=["description", "expert", "intermediate"], batch_size=512):
if r.get("description") and r.get("expert") and 300 < len(r["expert"]) < 3500:
rows.append(r)
if len(rows) > target * 6:
break
rng.shuffle(rows)
for r in rows[:target]:
user = rng.choice(["Plan how to model this part step by step, with exact dimensions: ",
"Give me precise build steps for: ", "Break this shape into exact modeling steps: "]) + r["description"].strip()
yield chat(user, r["expert"].strip())
def omar_cadquery(target: int, rng: random.Random, log):
rows = list(iter_rows("OmarK211/text-to-cadquery-v1", columns=["messages"]))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
msgs = [m for m in (r.get("messages") or []) if m.get("role") in ("user", "assistant") and m.get("content")]
if len(msgs) < 2 or msgs[0]["role"] != "user":
continue
out = [{"role": "system", "content": SYSTEM_PROMPT}] + [{"role": m["role"], "content": m["content"]} for m in msgs[:2]]
if _fits(out):
n += 1
yield out
# --------------------------------------------------------------- agent
AGENT_SYSTEM = SYSTEM_PROMPT + (
"\n\nYou are connected to a live Roblox Studio session. Use the tools to inspect the place "
"before changing it, make focused edits, and check your work."
)
def _parse_args(a):
if isinstance(a, dict):
return a
try:
v = json.loads(a or "{}")
return v if isinstance(v, dict) else {"value": v}
except Exception:
return {"input": str(a)}
def _tools_from_system(text: str) -> list[dict]:
for block in re.findall(r"```(?:json)?\s*(.*?)```", text or "", re.DOTALL):
try:
data = json.loads(block)
except Exception:
continue
items = data if isinstance(data, list) else data.get("tools", []) if isinstance(data, dict) else []
tools = []
for t in items:
if not isinstance(t, dict):
continue
fn = t.get("function", t)
if "name" in fn:
tools.append({"type": "function", "function": {
"name": fn["name"], "description": (fn.get("description") or "")[:300],
"parameters": fn.get("parameters") or fn.get("input_schema") or {"type": "object", "properties": {}}}})
if tools:
return tools
return []
def _agent_example(traj, tool_limit: int):
msgs = [{"role": "system", "content": AGENT_SYSTEM}]
tools: list[dict] = []
used: dict[str, set] = {}
for m in traj:
if isinstance(m, str):
try:
m = json.loads(m)
except Exception:
return None, None
role = m.get("role")
if role == "system":
tools = _tools_from_system(m.get("content") or "")
elif role == "user":
msgs.append({"role": "user", "content": (m.get("content") or "").strip()})
elif role == "assistant":
out = {"role": "assistant", "content": strip_think(m.get("content") or "")}
calls = []
for tc in m.get("tool_calls") or []:
fn = tc.get("function") or {}
name = fn.get("name")
if not name:
continue
args = _parse_args(fn.get("arguments"))
used.setdefault(name, set()).update(args)
calls.append({"id": tc.get("id") or f"call_{len(msgs)}", "type": "function",
"function": {"name": name, "arguments": args}})
if calls:
out["tool_calls"] = calls
if out["content"] or calls:
msgs.append(out)
elif role == "tool":
c = m.get("content")
c = c if isinstance(c, str) else json.dumps(c, ensure_ascii=False)
if len(c) > tool_limit:
c = c[:tool_limit] + "...(truncated)"
msgs.append({"role": "tool", "tool_call_id": m.get("tool_call_id"), "name": m.get("name"), "content": c})
if not tools:
tools = [{"type": "function", "function": {
"name": n, "description": f"Roblox Studio tool: {n.replace('_', ' ')}",
"parameters": {"type": "object", "properties": {k: {"type": "string"} for k in sorted(ks)}}}}
for n, ks in used.items()]
else:
tools = [t for t in tools if t["function"]["name"] in used] or tools
return msgs, tools
def roblox_agent(repo: str, target: int, rng: random.Random, log):
status: Counter = Counter()
kept = prefixes = 0
rows = []
for r in iter_rows(repo, columns=["trajectory", "exit_status", "category"], batch_size=16):
st = str(r.get("exit_status") or "none").lower()
status[st] += 1
if any(bad in st for bad in ("error", "fail", "timeout", "max", "limit", "abort", "crash")):
continue
rows.append(r)
log(f" exit_status: {dict(status.most_common(8))}")
rng.shuffle(rows)
for r in rows:
if kept >= target:
break
for limit in (1200, 500, 200):
msgs, tools = _agent_example(r.get("trajectory") or [], limit)
if not msgs or not any(m.get("tool_calls") for m in msgs):
break
if msgs[-1]["role"] == "tool": # end on the model, not on a tool result
msgs.append({"role": "assistant", "content": "Done."})
tool_tok = len(json.dumps(tools)) // 3
if est_tokens(msgs) + tool_tok <= MAX_TOKENS:
kept += 1
yield {"messages": msgs, "tools": tools}
break
if limit == 200: # still too long: keep the longest prefix that fits
for cut in range(len(msgs) - 1, 2, -1):
pre = msgs[:cut]
if pre[-1]["role"] != "assistant" or not pre[-1].get("content"):
continue
if any(m.get("tool_calls") for m in pre) and est_tokens(pre) + tool_tok <= MAX_TOKENS:
kept += 1
prefixes += 1
yield {"messages": pre, "tools": tools}
break
log(f" kept {kept} ({prefixes} cut to a prefix that fits)")
# --------------------------------------------------------------- luau
def _first_turns(pairs: list[dict], max_pairs: int = 2):
for k in range(min(max_pairs, len(pairs) // 2), 0, -1):
msgs = [{"role": "system", "content": SYSTEM_PROMPT}] + pairs[: 2 * k]
if _fits(msgs):
return msgs
return None
def luau_coder(target: int, rng: random.Random, log):
rows = list(iter_rows("khtsly/Luau-Coder-1.0-Preview-SFT", columns=["conversations"], batch_size=64))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
conv = [{"role": m["role"], "content": strip_think(m.get("content") or "")}
for m in (r.get("conversations") or []) if m.get("role") in ("user", "assistant")]
if len(conv) < 2 or conv[0]["role"] != "user" or not all(m["content"] for m in conv[:2]):
continue
msgs = _first_turns(conv)
if msgs:
n += 1
yield msgs
def luaudev(target: int, rng: random.Random, log):
roles = {"human": "user", "user": "user", "gpt": "assistant", "assistant": "assistant"}
picked = []
for r in iter_rows("Pinkstack/LuauDev-instructions-SFT-full", columns=["conversations"], batch_size=32):
picked.append(r)
if len(picked) >= target * 4:
break
rng.shuffle(picked)
n = 0
for r in picked:
if n >= target:
break
conv = [{"role": roles[m["from"]], "content": strip_think(m.get("value") or "")}
for m in (r.get("conversations") or []) if m.get("from") in roles]
if len(conv) < 2 or conv[0]["role"] != "user":
continue
msgs = _first_turns(conv, 1)
if msgs:
n += 1
yield msgs
def luau_reasoning(target: int, rng: random.Random, log):
rows = list(iter_rows("TorpedoSoftware/Roblox-Luau-Reasoning-v1.0", columns=["prompt", "code", "explanation"]))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
if not r.get("prompt") or not r.get("code"):
continue
a = _code_block(r["code"]) + "\n\n" + _trim(r.get("explanation") or "", 700)
msgs = chat(r["prompt"], a)
if _fits(msgs):
n += 1
yield msgs
def instruction_rows(repo: str, target: int, rng: random.Random, log, split: str = "train"):
rows = list(iter_rows(repo, split=split, columns=["instruction", "input", "output"]))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
ins, inp, out = (r.get("instruction") or "").strip(), (r.get("input") or "").strip(), (r.get("output") or "").strip()
if not ins or len(out) < 20:
continue
user = ins + (f"\n\n{inp}" if inp else "")
looks_code = bool(re.search(r"\b(local|function|end|Instance\.new|game:GetService)\b", out))
a = _code_block(out) if looks_code and "```" not in out else out
msgs = chat(user, a)
if _fits(msgs):
n += 1
yield msgs
def luau_corpus(target: int, rng: random.Random, log):
rows = list(iter_rows("Roblox/luau_corpus", columns=["prompt", "completion"]))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
p, c = (r.get("prompt") or "").strip("\n"), (r.get("completion") or "").strip("\n")
if len(p) < 80 or len(c) < 80 or len(p) + len(c) > 6000:
continue
msgs = chat(f"Continue this Roblox Luau code:\n\n```lua\n{p}\n```", f"```lua\n{c}\n```")
n += 1
yield msgs
# --------------------------------------------------------------- knowledge
def docs_rows(repo: str, target: int, rng: random.Random, log, config="default", title_col="title"):
cols = ["title", "url", "content"] if title_col == "title" else ["url", "content"]
rows = list(iter_rows(repo, config=config, columns=cols, batch_size=64))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
content = (r.get("content") or "").strip()
title = (r.get("title") or "").strip()
if not title:
url = (r.get("url") or "").rstrip("/")
title = pretty_name(url.rsplit("/", 1)[-1].split(".")[0]) if url else ""
if len(content) < 300 or not title:
continue
q = rng.choice(["Explain {t} in Roblox.", "What is {t}?", "How does {t} work in Roblox?", "Tell me about {t}."]).format(t=title)
msgs = chat(q, _trim(content, 2600))
if _fits(msgs):
n += 1
yield msgs
def devforum(target: int, rng: random.Random, log):
rows = list(iter_rows("khtsly/devforum-roblox-text", config="all", columns=["title", "content", "category"], batch_size=64))
rng.shuffle(rows)
n = 0
for r in rows:
if n >= target:
break
content, title = (r.get("content") or "").strip(), (r.get("title") or "").strip()
if len(content) < 300 or not title:
continue
msgs = chat(f"From the Roblox DevForum: {title}. What does it say?", _trim(content, 2600))
if _fits(msgs):
n += 1
yield msgs
# --------------------------------------------------------------- eval
def robloxqa_eval(rng: random.Random, limit: int = 1000):
rows = list(iter_rows("TorpedoSoftware/RobloxQA-v2.0", split="test"))
rng.shuffle(rows)
for r in rows[:limit]:
choices = [r["answer"], r["incorrect_0"], r["incorrect_1"], r["incorrect_2"]]
order = list(range(4))
rng.shuffle(order)
yield {"question": r["question"], "choices": [choices[i] for i in order], "answer": order.index(0)}
# --------------------------------------------------------------- Radin's own repo
BLOXY_TRAINING_ZIP = "https://github.com/Radin-dev1/BloxyAItraining/raw/main/Ropilot-Studio-training-data-inspection.zip"
SKILL_QUESTIONS = {
"Anti-Patterns": ["What should I avoid when {topic}?", "What are the common mistakes when {topic}?"],
"Limitations": ["What are the Studio MCP limits and workarounds when {topic}?"],
"Build Process": ["Walk me through the process for {topic}.", "What steps do you follow when {topic}?"],
"Verification": ["How do you check your work after {topic}?"],
"Folder": ["How should I organize folders when {topic}?"],
"Quick Reference": ["Give me a quick reference for {topic}.", "What are the key rules for {topic}?"],
"Checklist": ["Give me a review checklist for {topic}."],
"Domain Knowledge": ["What Roblox details matter when {topic}?"],
"Design Brief": ["What should a design brief include before {topic}?"],
}
SKILL_TOPICS = {
"building-3d-objects": "building a single object or prop in Roblox Studio",
"building-maps": "building a whole map in Roblox Studio",
"roblox-best-practices": "writing Luau for a Roblox game",
"roblox-building": "building geometry and props with Luau",
"roblox-design-consultant": "designing a build from a vague request",
"roblox-game-design": "designing a Roblox game's core loop",
"roblox-luau-core": "writing Luau",
"roblox-studio-mcp": "working in Roblox Studio through MCP",
}
def bloxy_skill_guides(target: int, rng: random.Random, log):
"""Roblox skill guides from Radin-dev1/BloxyAItraining, split into Q&A by section.
The SuperbulletAI zip in that repo is deliberately NOT used: it is code extracted
from a proprietary app with no redistribution license.
"""
import io
import urllib.request
import zipfile
raw = urllib.request.urlopen(BLOXY_TRAINING_ZIP, timeout=60).read()
zf = zipfile.ZipFile(io.BytesIO(raw))
out = []
for name in zf.namelist():
if not name.endswith("SKILL.md"):
continue
skill = name.rstrip("/").split("/")[-2]
topic = SKILL_TOPICS.get(skill, skill.replace("-", " "))
text = zf.read(name).decode("utf-8", "replace")
text = re.sub(r"^---.*?---\s*", "", text, flags=re.DOTALL) # drop frontmatter
text = re.sub(r"\*\*AUTHORITY\*\*:.*?\n", "", text)
sections = re.split(r"\n(?=## )", text)
for sec in sections[1:]:
head, _, body = sec.partition("\n")
head = head.lstrip("# ").strip()
body = body.strip()
if len(body) < 200 or re.search(r"When to Load|Supplementary|Reference Routing|Session", head):
continue
qs = next((v for k, v in SKILL_QUESTIONS.items() if k.lower() in head.lower()), [])
qs = qs + [f"Explain '{head}' for {{topic}}.", f"I'm {{topic}}. What do I need to know about {head.lower()}?"]
for q in qs[:3]:
msgs = chat(q.format(topic=topic), _trim(body, 4500))
if _fits(msgs):
out.append(msgs)
log(f" {len(out)} Q&A pairs from the skill guides")
rng.shuffle(out)
yield from out[:target]
# --------------------------------------------------------------- Hack337 curated schematics
def hack337_schematics(target: int, rng: random.Random, log, max_parts: int = 100):
"""Hack337/Minecraft-Schematics (MIT): 669 curated builds as JSON grids
(layers[y][z][x] chars + palette) with an English request per build.
Converted to Roblox Parts; rotated copies top up the count."""
from huggingface_hub import snapshot_download
root = snapshot_download("Hack337/Minecraft-Schematics", repo_type="dataset",
allow_patterns=["blueprints/*.json", "blueprints_mapping.jsonl"])
names = {}
with open(f"{root}/blueprints_mapping.jsonl", encoding="utf-8") as f:
for line in f:
try:
r = json.loads(line)
except Exception:
continue
if r.get("filename") and r.get("short_name_en"):
names[r["filename"]] = r["short_name_en"].strip()
builds = []
for fn, req in names.items():
try:
bp = json.load(open(f"{root}/blueprints/{fn}", encoding="utf-8"))
except Exception:
continue
pal = bp.get("palette") or {}
blocks = []
for y, layer in enumerate(bp.get("layers") or []):
for z, row in enumerate(layer):
for x, ch in enumerate(row):
if ch != "." and ch in pal:
blocks.append((x, y, z, pal[ch]))
if 20 <= len(blocks) <= 12000:
builds.append((req, blocks))
log(f" {len(builds)} usable builds of {len(names)}")
rng.shuffle(builds)
reasons: Counter = Counter()
made = 0
for rot in (0, 1, 2, 3): # original first, then rotated copies if more are needed
for req, blocks in builds:
if made >= target:
log(f" rejected: {dict(reasons.most_common(5))}")
return
thing = re.sub(r"^(please\s+)?(build|make|create)\s+(me\s+)?", "", req, flags=re.I).strip() or "build"
user = req[:1].upper() + req[1:] if rot == 0 else rng.choice(
[f"Build {thing}.", f"make {thing}", f"Can you build {thing} in Roblox?", f"Create {thing} out of parts."])
ex, why = minecraft.make_example(thing, blocks, rng, max_parts, rotate=rot, desc=user)
if ex is None:
reasons[str(why)] += 1
continue
msgs = chat(*ex)
if not _fits(msgs, BUILD_LIMIT):
reasons["too many tokens"] += 1
continue
made += 1
yield msgs
log(f" rejected: {dict(reasons.most_common(5))}")
# --------------------------------------------------------------- text -> brick builds
BRICK_RE = re.compile(r"(\d+)x(\d+)\s*\((\d+),\s*(\d+),\s*(\d+)\)")
BRICK_UNIT, BRICK_LAYER = 2.0, 2.4 # studs per brick stud / per brick layer (toy brick ratio)
CAPTION_STYLE = [ # (keywords, material, colors)
(("wood", "wooden", "oak", "timber"), "WoodPlanks", ["b8945f", "7a5a34", "4f3218"]),
(("metal", "steel", "iron", "chrome", "aluminum"), "Metal", ["8e8e86", "6e7378", "c8c8c8"]),
(("glass", "transparent"), "Glass", ["c0e4ec"]),
(("stone", "concrete", "brick"), "Concrete", ["a3a2a5", "8a8478"]),
(("red",), "SmoothPlastic", ["c4281c"]), (("blue",), "SmoothPlastic", ["0d69ac"]),
(("green",), "SmoothPlastic", ["4b974b"]), (("yellow",), "SmoothPlastic", ["f5cd30"]),
(("black", "dark"), "SmoothPlastic", ["1b2a35"]), (("white",), "SmoothPlastic", ["f2f3f3"]),
]
def brick_builds(target: int, rng: random.Random, log, max_parts: int = 90):
"""AvaLovelace/StableText2Brick: caption -> physically stable brick structure.
Bricks ('2x4 (x,y,z)', z = layer) are voxelized and greedy-merged into Parts,
then written in the same P(...) build format as every other Bloxy build.
"""
from .luau_build import Build, Part, answer as build_answer
from .common import pascal
rows = list(iter_rows("AvaLovelace/StableText2Brick", columns=["captions", "bricks", "category_id"], batch_size=512))
rng.shuffle(rows)
seen_objects, n, reasons = set(), 0, Counter()
for r in rows:
if n >= target:
break
caps = [c for c in (r.get("captions") or []) if c and len(c) > 15]
bricks = BRICK_RE.findall(r.get("bricks") or "")
if not caps or len(bricks) < 4:
reasons["empty"] += 1
continue
cells = set()
for h, w, x, y, z in bricks:
h, w, x, y, z = map(int, (h, w, x, y, z))
for i in range(h):
for j in range(w):
cells.add((x + i, z, y + j)) # (x, up, z) like Roblox
boxes = list(minecraft.greedy_boxes(cells, "full"))
if len(boxes) > max_parts:
reasons["too many parts"] += 1
continue
cap = rng.choice(caps).strip().rstrip(".")
low = cap.lower()
mat, cols = "SmoothPlastic", ["a3a2a5", "c4281c", "0d69ac", "f5cd30", "4b974b"]
for keys, m, cs in CAPTION_STYLE:
if any(re.search(rf"\b{k}\b", low) for k in keys):
mat, cols = m, cs
break
color = rng.choice(cols)
xs = [c[0] for c in cells]; zs = [c[2] for c in cells]
cx, cz = (min(xs) + max(xs) + 1) / 2, (min(zs) + max(zs) + 1) / 2
name = " ".join(re.findall(r"[A-Za-z]+", low)[:4]) or "object"
b = Build(pascal(name))
for x0, y0, z0, dx, dy, dz in boxes:
b.add(Part("Block", (dx * BRICK_UNIT, dy * BRICK_LAYER, dz * BRICK_UNIT),
((x0 - cx + dx / 2) * BRICK_UNIT, (y0 + dy / 2) * BRICK_LAYER, (z0 - cz + dz / 2) * BRICK_UNIT),
mat, color, None, 0.4 if mat == "Glass" else 0.0))
w, hgt, d = b.bounds()
user = rng.choice(["Build {c}.", "build {c}", "Make {c} out of parts.", "Can you build {c}?",
"Create {c} in Roblox Studio."]).format(c=cap[:1].lower() + cap[1:])
intro = f"Here it is: {len(boxes)} anchored parts, about {int(w)}x{int(d)} studs and {int(hgt)} studs tall, built layer by layer so every part rests on the one below."
msgs = chat(user, build_answer(intro, b))
if _fits(msgs, BUILD_LIMIT):
n += 1
yield msgs
log(f" rejected: {dict(reasons.most_common(4))}")