Upload folder using huggingface_hub

scripts/scaffold_convex_decomposition.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+import argparse
+import json
+from datetime import date
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def parse_simple_yaml(path: Path):
+    data = {}
+    current_key = None
+    for raw in path.read_text().splitlines():
+        if not raw.strip() or raw.lstrip().startswith("#"):
+            continue
+        if raw.startswith("  - ") and current_key:
+            data.setdefault(current_key, []).append(raw.strip()[2:].strip())
+            continue
+        if ":" in raw and not raw.startswith(" "):
+            key, value = raw.split(":", 1)
+            key = key.strip()
+            value = value.strip()
+            current_key = key
+            if value == "":
+                data[key] = []
+            else:
+                data[key] = value.strip('"').strip("'")
+    return data
+
+
+def yaml_scalar(value):
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if value is None:
+        return "null"
+    if isinstance(value, (int, float)):
+        return str(value)
+    text = str(value)
+    if text == "":
+        return '""'
+    if any(ch in text for ch in [":", "#", "{", "}", "[", "]", ",", "\"", "'", "\n"]) or text.startswith(" ") or text.endswith(" "):
+        return json.dumps(text, ensure_ascii=False)
+    return text
+
+
+def dump_yaml(mapping, indent=0):
+    lines = []
+    pad = " " * indent
+    for key, value in mapping.items():
+        if isinstance(value, dict):
+            lines.append(f"{pad}{key}:")
+            lines.extend(dump_yaml(value, indent + 2))
+        elif isinstance(value, list):
+            if not value:
+                lines.append(f"{pad}{key}: []")
+            else:
+                lines.append(f"{pad}{key}:")
+                for item in value:
+                    if isinstance(item, dict):
+                        lines.append(f"{pad}  -")
+                        lines.extend(dump_yaml(item, indent + 4))
+                    else:
+                        lines.append(f"{pad}  - {yaml_scalar(item)}")
+        else:
+            lines.append(f"{pad}{key}: {yaml_scalar(value)}")
+    return lines
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Scaffold a derived convex decomposition asset directory.")
+    parser.add_argument("raw_asset_dir", help="Path to a raw asset directory under assets/<source>/raw/...")
+    parser.add_argument("--variant", default="vhacd_v1", help="Derived asset variant suffix.")
+    parser.add_argument("--tool", default="vhacd", help="Convex decomposition tool name.")
+    parser.add_argument("--tool-version", default="TBD", help="Convex decomposition tool version.")
+    args = parser.parse_args()
+
+    raw_asset_dir = Path(args.raw_asset_dir).resolve()
+    raw_rel = raw_asset_dir.relative_to(ROOT / "assets")
+    parts = raw_rel.parts
+    if len(parts) < 5 or parts[1] != "raw":
+        raise SystemExit("raw_asset_dir must be under assets/<source>/raw/<asset_type>/<category>/<asset_id>")
+
+    source = parts[0]
+    asset_type = parts[2]
+    category = parts[3]
+    asset_id = parts[4]
+
+    raw_meta_path = raw_asset_dir / "metadata.yaml"
+    raw_meta = parse_simple_yaml(raw_meta_path) if raw_meta_path.exists() else {}
+    license_name = raw_meta.get("license", "unknown")
+    origin_url = raw_meta.get("origin_url", "")
+    source_commit = raw_meta.get("source_commit")
+
+    derived_asset_id = f"{asset_id}_{args.variant}"
+    derived_dir = ROOT / "assets" / source / "derived" / "convex_decompositions" / category / derived_asset_id
+    if derived_dir.exists():
+        raise SystemExit(f"destination already exists: {derived_dir}")
+
+    (derived_dir / "meshes").mkdir(parents=True, exist_ok=False)
+    (derived_dir / "mjcf").mkdir(parents=True, exist_ok=False)
+    (derived_dir / "logs").mkdir(parents=True, exist_ok=False)
+
+    metadata = {
+        "asset_id": f"{source}.convex_decompositions.{category}.{derived_asset_id}",
+        "source": source,
+        "source_asset_id": asset_id,
+        "asset_type": "convex_decompositions",
+        "category": category,
+        "format": "obj_mjcf_include",
+        "entry_file": "mjcf/convex_collision_include.xml",
+        "license": license_name,
+        "origin_url": origin_url,
+        "path": derived_dir.relative_to(ROOT).as_posix(),
+        "storage_mode": "derived",
+        "derived_from": [raw_asset_dir.relative_to(ROOT).as_posix()],
+        "derivation_method": "convex_decomposition",
+        "decomposition_tool": args.tool,
+        "decomposition_version": args.tool_version,
+        "decomposition_params_file": "logs/decomposition.json",
+        "validation_status": "scaffolded",
+        "tags": [source, "convex_decomposition", "collision"],
+    }
+    if source_commit:
+        metadata["source_commit"] = source_commit
+
+    if "readiness_level" in raw_meta:
+        metadata["readiness_level"] = raw_meta["readiness_level"]
+
+    (derived_dir / "metadata.yaml").write_text("\n".join(dump_yaml(metadata)) + "\n")
+
+    source_refs = {
+        "raw_asset": raw_asset_dir.relative_to(ROOT).as_posix(),
+        "raw_entry_file": (raw_asset_dir / raw_meta.get("entry_file", "model.xml")).relative_to(ROOT).as_posix(),
+    }
+    (derived_dir / "source_refs.yaml").write_text("\n".join(dump_yaml(source_refs)) + "\n")
+
+    include_xml = f"""<!-- Scaffolded convex collision include for {raw_asset_dir.relative_to(ROOT).as_posix()} -->
+<mujocoinclude>
+  <!-- Replace with convex collision geoms generated by {args.tool} -->
+</mujocoinclude>
+"""
+    (derived_dir / "mjcf" / "convex_collision_include.xml").write_text(include_xml)
+
+    logs = {
+        "tool": args.tool,
+        "tool_version": args.tool_version,
+        "created_at": str(date.today()),
+        "raw_asset": raw_asset_dir.relative_to(ROOT).as_posix(),
+        "derived_asset": derived_dir.relative_to(ROOT).as_posix(),
+        "params": {},
+        "inputs": [],
+        "outputs": [],
+    }
+    (derived_dir / "logs" / "decomposition.json").write_text(json.dumps(logs, indent=2, ensure_ascii=False) + "\n")
+
+    readme = f"""# Convex decomposition scaffold
+
+Raw asset:
+
+```text
+{raw_asset_dir.relative_to(ROOT).as_posix()}
+```
+
+Derived asset:
+
+```text
+{derived_dir.relative_to(ROOT).as_posix()}
+```
+
+This directory is a scaffold only. Populate `meshes/` and replace the include file with real convex collision geometry before registering it in the manifest.
+"""
+    (derived_dir / "README.md").write_text(readme)
+
+    print(derived_dir.relative_to(ROOT).as_posix())
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_asset.py

@@ -54,6 +54,7 @@ def validate_one(asset_dir, manifest):
     errors = []
     asset_dir = asset_dir.resolve()
     rel = asset_dir.relative_to(ROOT).as_posix()
+    parts = asset_dir.relative_to(ROOT / "assets").parts
 
     metadata_path = asset_dir / "metadata.yaml"
     if not metadata_path.exists():
@@ -67,8 +68,33 @@ def validate_one(asset_dir, manifest):
     if not entry_path.exists():
         errors.append(f"missing entry_file: {entry_path}")
 
+    if len(parts) < 5:
+        errors.append(f"asset path must follow assets/<source>/(raw|derived)/<asset_type>/<category>/<asset_id>: {rel}")
+    else:
+        source, storage_kind, asset_type, category, asset_id = parts[:5]
+        if storage_kind not in {"raw", "derived"}:
+            errors.append(f"asset storage kind must be raw or derived: {rel}")
+        expected_asset_id = f"{source}.{asset_type}.{category}.{asset_id}"
+        if metadata.get("source") != source:
+            errors.append(f"metadata source mismatch: {rel}: expected {source}, got {metadata.get('source')}")
+        if metadata.get("asset_type") != asset_type:
+            errors.append(f"metadata asset_type mismatch: {rel}: expected {asset_type}, got {metadata.get('asset_type')}")
+        if metadata.get("category") != category:
+            errors.append(f"metadata category mismatch: {rel}: expected {category}, got {metadata.get('category')}")
+        if metadata.get("asset_id") != expected_asset_id:
+            errors.append(f"metadata asset_id mismatch: {rel}: expected {expected_asset_id}, got {metadata.get('asset_id')}")
+        if metadata.get("path") != rel:
+            errors.append(f"metadata path mismatch: {rel}: got {metadata.get('path')}")
+        if storage_kind == "derived" and metadata.get("storage_mode") not in {"derived", "converted", "generated"}:
+            errors.append(f"derived asset missing storage_mode metadata: {rel}")
+
     if rel not in manifest:
         errors.append(f"missing manifest entry for path: {rel}")
+    else:
+        row = manifest[rel]
+        for key in ("asset_id", "source", "asset_type", "category", "entry_file", "path"):
+            if metadata.get(key) is not None and row.get(key) != metadata.get(key):
+                errors.append(f"manifest {key} mismatch: {rel}: metadata={metadata.get(key)} manifest={row.get(key)}")
 
     if entry_path.exists() and entry_path.is_file() and entry_path.suffix == ".xml":
         try: