Download code/bloxy_data/sources.py from Radinkazemian/bloxy-data-v1: direct link, hf CLI and curl.
- Browser
- Download file 30.9 kB
-
https://huggingface.co/datasets/Radinkazemian/bloxy-data-v1/resolve/main/code/bloxy_data/sources.py
- Command line
-
hf download hf://datasets/Radinkazemian/bloxy-data-v1/code/bloxy_data/sources.py
-
curl -L -o sources.py https://huggingface.co/datasets/Radinkazemian/bloxy-data-v1/resolve/main/code/bloxy_data/sources.py
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))}") | |