"""Find assets in the CodePawl asset index from a plain request. Usage: query.py "wooden crate, 0.5 m, game tier" [--top 10] [--source kenney] [--free] [--trainable] [--rigged] [--json] A size like "0.5 m" or "30 cm" keeps assets whose scale is within half to double that size. "game", "web", "mobile" or "film" (with or without "tier") picks the use whose recommended tier is shown. "material", "surface", "model", "decal", "hdri" or "character" narrows the kind; "tileable" or "seamless" keeps repeating surfaces. "lowpoly", "stylized" or "photoreal" narrows the style. Every other word is matched against search_text; rows rank by how many words match, then by real size known, then by texel density. --free keeps assets whose files may be shipped (CC0), --trainable drops rows Fab flags NoAI, --rigged keeps rigged ones. Each result says how to get it: a download URL for CC0 assets, or the Fab page plus the optimizer command for Megascans. """ import json import re import sys from pathlib import Path USES = {"game", "web", "mobile", "film"} KIND_WORDS = {"material": "material", "surface": "material", "texture": "material", "model": "model", "prop": "model", "decal": "decal", "hdri": "hdri", "skybox": "hdri", "brush": "brush", "atlas": "atlas"} STYLE_WORDS = {"lowpoly": "lowpoly", "stylized": "stylized", "stylised": "stylized", "photoreal": "photoreal", "realistic": "photoreal", "scanned": "photoreal"} STOP_WORDS = {"a", "an", "the", "tier", "for", "of", "with", "and", "in", "size", "about", "need", "want", "i"} JSON_COLUMNS = ("recommended_tier", "files", "get") def load_rows(path): path = Path(path) if path.suffix == ".parquet": import pyarrow.parquet as parquet rows = parquet.read_table(path).to_pylist() for row in rows: for column in JSON_COLUMNS: row[column] = json.loads(row[column]) if row.get(column) else None return rows return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()] def parse_request(request): text = request.lower() wanted = {"size_m": None, "use": None, "kind": None, "style": None, "character": False, "tileable": False, "words": []} size = re.search(r"(\d+(?:\.\d+)?)\s*(cm|m)\b", text) if size: wanted["size_m"] = float(size.group(1)) / (100 if size.group(2) == "cm" else 1) text = text.replace(size.group(0), " ") for word in re.findall(r"[a-z]+", text.replace("low poly", "lowpoly")): if word in USES: wanted["use"] = word elif word in KIND_WORDS: wanted["kind"] = KIND_WORDS[word] elif word in STYLE_WORDS: wanted["style"] = STYLE_WORDS[word] elif word in ("character", "characters", "rigged"): wanted["character"] = True elif word in ("tileable", "seamless", "tiling"): wanted["tileable"] = True elif word not in STOP_WORDS: wanted["words"].append(word.rstrip("s") if len(word) > 3 else word) return wanted def score(row, wanted): if wanted["kind"] and row["kind"] != wanted["kind"]: return None if wanted["style"] and row["style"] != wanted["style"]: return None if wanted["character"] and not row.get("rigged"): return None if wanted["tileable"] and not row.get("tileable"): return None if wanted["size_m"] is not None: scale = row.get("scale_m") if scale is None or not (wanted["size_m"] / 2 <= scale <= wanted["size_m"] * 2): return None text = row["search_text"] matched = sum(1 for word in wanted["words"] if re.search(rf"\b{re.escape(word)}", text)) if wanted["words"] and matched == 0: return None title = (row.get("title") or "").lower() in_title = sum(1 for word in wanted["words"] if re.search(rf"\b{re.escape(word)}", title)) return (matched, in_title, row.get("scale_m") is not None, row.get("texel_density_px_m") or 0) def how_to_get(row, use): get = row.get("get") or {} files = row.get("files") or {} tier = (row.get("recommended_tier") or {}).get(use) if files: tier_key = (tier or "web").split(" ")[0] return files.get(tier_key) or files.get("web") if get.get("how") == "claim on Fab": return f"claim {get['url']} then: {get['then']}" if get.get("file_in_kit"): return f"{get['url']} (kit zip), file {get['file_in_kit']}" return get.get("url") def main(): sys.stdout.reconfigure(encoding="utf-8", errors="replace") arguments = sys.argv[1:] top = int(arguments[arguments.index("--top") + 1]) if "--top" in arguments else 10 rows = load_rows(arguments[0]) wanted = parse_request(arguments[1]) if "--source" in arguments: source = arguments[arguments.index("--source") + 1] rows = [row for row in rows if row["source"] == source] if "--free" in arguments: rows = [row for row in rows if row["redistributable"]] if "--trainable" in arguments: rows = [row for row in rows if row["redistributable"] or row.get("no_ai") is False] if "--rigged" in arguments: wanted["character"] = True ranked = [(row_score, row) for row in rows if (row_score := score(row, wanted)) is not None] ranked.sort(key=lambda pair: pair[0], reverse=True) use = wanted["use"] or "game" results = [{ "title": row["title"], "source": row["source"], "kind": row["kind"], "style": row["style"], "scale_m": row["scale_m"], "licence": row["licence"], "free_to_ship": row["redistributable"], "use": use, "tier": (row.get("recommended_tier") or {}).get(use), "get": how_to_get(row, use), "credit": row.get("credit"), "no_ai": row.get("no_ai"), "page": row["source_url"], } for _, row in ranked[:top]] if "--json" in arguments: print(json.dumps({"request": wanted, "matches": len(ranked), "results": results}, ensure_ascii=False, indent=1)) return print(f"{len(ranked)} matches for {arguments[1]!r}") for result in results: size = f"{result['scale_m']} m" if result["scale_m"] else "size ?" print(f"- {result['title']} ({result['source']}, {result['kind']}, {size}, {result['use']}: {result['tier']})\n get: {result['get']}") if __name__ == "__main__": main()