yubi-mujoco 0.1.0__py3-none-any.whl

yubi_mujoco/__init__.py

@@ -0,0 +1,13 @@
+"""Arm-free YUBI simulation. Set MUJOCO_GL before first environment import."""
+
+__all__ = ["YubiEnv", "SimConfig"]
+__version__ = "0.1.0"
+
+
+def __getattr__(name):
+    # Keep CLI import lightweight so headless GL selection precedes MuJoCo import.
+    if name in __all__:
+        from .env import YubiEnv, SimConfig
+
+        return {"YubiEnv": YubiEnv, "SimConfig": SimConfig}[name]
+    raise AttributeError(name)

yubi_mujoco/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

yubi_mujoco/_images.py

@@ -0,0 +1,31 @@
+"""Write RGB PNG images without optional video dependencies."""
+
+from pathlib import Path
+import struct
+import zlib
+
+import numpy as np
+
+
+def write_png(path, pixels):
+    """Write an HWC uint8 RGB image as a lossless PNG."""
+    pixels = np.asarray(pixels)
+    if pixels.ndim != 3 or pixels.shape[2] != 3 or pixels.dtype != np.uint8:
+        raise ValueError("pixels must have shape (height, width, 3) and dtype uint8")
+    height, width, _ = pixels.shape
+    if not height or not width:
+        raise ValueError("image dimensions must be positive")
+
+    def chunk(kind, data):
+        return (
+            struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data))
+        )
+
+    header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
+    rows = b"".join(b"\0" + row.tobytes() for row in pixels)
+    Path(path).write_bytes(
+        b"\x89PNG\r\n\x1a\n"
+        + chunk(b"IHDR", header)
+        + chunk(b"IDAT", zlib.compress(rows))
+        + chunk(b"IEND", b"")
+    )

yubi_mujoco/adapter.py

@@ -0,0 +1,107 @@
+"""Local Policy(checkpoint_dir).infer(obs) evaluation; no model/network side effects."""
+
+from pathlib import Path
+import importlib.util
+import time
+import numpy as np
+from .geometry import pose
+
+
+def validate_chunk(actions, min_rows=16, *, executed_rows=None):
+    if not isinstance(min_rows, int) or min_rows < 1:
+        raise ValueError("min_rows must be a positive integer")
+    a = np.asarray(actions)
+    if a.ndim != 2 or a.shape[1] != 16 or a.shape[0] < min_rows:
+        raise ValueError(f"policy must return (N,16) with N>={min_rows}; received {a.shape}")
+    if not np.issubdtype(a.dtype, np.number) or np.iscomplexobj(a) or not np.isfinite(a).all():
+        raise ValueError("policy actions must be finite numeric values")
+    if executed_rows is None:
+        executed_rows = len(a)
+    if not isinstance(executed_rows, int) or not 1 <= executed_rows <= len(a):
+        raise ValueError("executed_rows must be an integer within the returned chunk")
+    for row in a[:executed_rows]:
+        pose(row[:7])
+        pose(row[7:14])
+    return a.astype(np.float64)
+
+
+class HoldPolicy:
+    def __init__(self, checkpoint_dir=None):
+        pass
+
+    def infer(self, obs):
+        a = np.zeros((32, 16), dtype=np.float32)
+        a[:, 6] = a[:, 13] = 1
+        a[:, 14:16] = obs["observation.joint_states"]
+        return a
+
+
+def load_policy(policy_path, checkpoint_dir):
+    path = Path(policy_path).resolve()
+    if not path.is_file():
+        raise FileNotFoundError(path)
+    spec = importlib.util.spec_from_file_location("yubi_user_policy", path)
+    if spec is None or spec.loader is None:
+        raise ValueError(f"cannot import {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.Policy(str(Path(checkpoint_dir).resolve()))
+
+
+def run_policy(
+    env, policy, *, adopt_rows=16, max_calls=None, on_step=None, translation_frame="body"
+):
+    """Measure simulation task success, not Arena real-robot scores.
+
+    Simulator pauses while infer runs, as described by the public robot contract.
+    Translation frame and row frequency are explicit caller choices.
+    No dataset-only gripper time shift is applied to live actions.
+    """
+    if not isinstance(adopt_rows, int) or adopt_rows <= 0:
+        raise ValueError("adopt_rows must be a positive integer")
+    if max_calls is not None and (not isinstance(max_calls, int) or max_calls <= 0):
+        raise ValueError("max_calls must be a positive integer")
+    latencies = []
+    calls = 0
+    rate_limited_steps = 0
+    status = "running"
+    error = None
+    while not env._done and (max_calls is None or calls < max_calls):
+        obs = env.observe(images=True)
+        start = time.perf_counter()
+        try:
+            actions = validate_chunk(policy.infer(obs), executed_rows=adopt_rows)
+            latencies.append(time.perf_counter() - start)
+            # Fail before partially executing a chunk with illegal gripper positions.
+            for row in actions[:adopt_rows]:
+                env._motor_to_jaw(row[14:16])
+            calls += 1
+            for action in actions[:adopt_rows]:
+                _, _, terminated, truncated, info = env.step_delta(
+                    action, translation_frame=translation_frame
+                )
+                rate_limited_steps += int(any(info["target_rate_limited"]))
+                if on_step:
+                    on_step(env, info)
+                if terminated or truncated:
+                    break
+        except (ValueError, RuntimeError, FloatingPointError) as exc:
+            status, error = "invalid_policy_output", f"{type(exc).__name__}: {exc}"
+            break
+    if status == "running":
+        status = "success" if env.info()["success"] else "horizon" if env._done else "call_limit"
+    return {
+        **env.info(),
+        "status": status,
+        "error": error,
+        "policy_calls": calls,
+        "latency_seconds": latencies,
+        "latency_p95_seconds": float(np.percentile(latencies, 95)) if latencies else None,
+        "rate_limited_steps": rate_limited_steps,
+        "action_hz": env.config.control_hz,
+        "translation_frame": translation_frame,
+        "adopt_rows": adopt_rows,
+        "scoring": "local_sim_task_success_only",
+        "camera_calibrated": False,
+        "motor_mapping_calibrated": False,
+    }

yubi_mujoco/assets/NOTICE.md

@@ -0,0 +1,34 @@
+# YUBI MuJoCo notices
+
+Original simulation software: Copyright (c) 2026 YUBI simulation contributors,
+MIT license. The root LICENSE does not relicense third-party assets.
+
+Toyota-derived CAD and transformation/grouping metadata:
+Copyright 2026 Toyota Motor Corporation, CERN-OHL-W-2.0.
+Full license: licenses/CERN-OHL-W-2.0.txt.
+
+Modification notice, 2026-10-01: tessellated the pinned robot-gripper STEP
+assembly; partitioned 97 solid leaves into fixed palm and moving jaws;
+converted millimeters to meters and re-expressed geometry in a canonical
+root frame and verified hinge-local frames. No intentional solid-geometry
+design changes. Distributed meshes are 13 disjoint material partitions;
+redundant whole-body aggregate meshes are omitted. Approximate black/red
+rendering colors follow the official assembled gripper reference.
+mass_properties.json holds body mass, center-of-mass and inertia estimates
+computed from the same STEP solids with stated material assumptions.
+The CAD-derived meshes and transformation/grouping metadata retain
+CERN-OHL-W-2.0. See SOURCE.md for complete source and regeneration instructions.
+
+Published software/API/coordinate conventions were consulted from:
+- airoa-org/yubi-sw, commit 1eccb041efc4d8966b03e4ccf4b402aa79d78be4
+  Copyright 2026 AI Robot Association
+- airoa-org/umi-arena-evaluation, commit 8763f10a022139dbcf4293b60f797a717d8bd1ad
+These upstream references use Apache-2.0; a copy is in licenses/Apache-2.0.txt.
+No pretrained weights or restricted datasets are redistributed.
+
+OpenArm MuJoCo (https://github.com/enactic/openarm_mujoco) was consulted as a
+packaging/usability reference; its code and robot assets are not included.
+
+This is an independent project. It is not endorsed or certified by Toyota,
+AIRoA, or Enactic. No trademark rights are granted. See the full licenses for
+warranty disclaimers and other terms.

yubi_mujoco/assets/SOURCE.md

@@ -0,0 +1,42 @@
+# Complete source and asset provenance
+
+For a published 0.1.0 release, obtain its complete corresponding source as
+`yubi_mujoco-0.1.0.tar.gz`, the same-version source distribution (sdist), at:
+https://pypi.org/project/yubi-mujoco/0.1.0/#files
+
+The sdist contains the unmodified source STEP, original hardware license and
+commercial guidance, the CAD exporter, and all grouping/transformation data.
+It must be published alongside the wheel. A wheel alone is not the complete
+CAD source. Repository source is also intended at:
+https://github.com/k1000dai/yubi_mujoco
+
+Original hardware source: https://github.com/Toyota/yubi-hw
+Pinned revision: dd8bd13d2fd8e5003057243576f88be333d95fc5
+Original path: STEP/gripper/YUBI Gripper Assy_Dynamixel_ver2.STEP
+SHA-256: 0e60bf62de970e5fae5e7cff104f547a954ef8d5d7b9dde9835b381b95f4fcc8
+Copyright 2026 Toyota Motor Corporation. License: CERN-OHL-W-2.0.
+See NOTICE.md for the dated modification notice and licenses/ for full terms.
+
+## Regenerate
+
+Extract the sdist, change into its root, and use a Python interpreter with
+FreeCAD 1.0 native Python modules (Import, Part, and MeshPart) available:
+
+    python cad/fetch_source.py
+    /usr/bin/python3 cad/export.py
+
+The first command verifies the bundled STEP; it downloads only that pinned
+public source if it is absent. The exporter itself uses no network. Set
+FREECAD_LIB for an alternate FreeCAD Python library location. FreeCAD is not
+a runtime dependency and is installed separately, not as a pip extra.
+
+The exporter verifies the source hash, all 97 expected solid leaves, their
+unique body assignments, 8 mm shaft bores, and parallel-finger orientation.
+Default tessellation: 0.12 mm linear deflection, 0.35 rad angular deflection.
+Version-specific FreeCAD/OpenCascade tessellation may change mesh hashes.
+
+Runtime meshes and corresponding SHA-256 hashes are listed in
+cad_manifest.json; exact frame/pivot transforms are in cad_assembly.json.
+Body mass estimates in mass_properties.json are regenerated by
+cad/mass_properties.py, which needs OpenCascade's Python bindings (cadquery-ocp).
+Detailed geometry derivation is in docs/CAD_PROVENANCE.md in the sdist.

yubi_mujoco/assets/cad_assembly.json

@@ -0,0 +1,167 @@
+{
+  "schema_version": 1,
+  "source_step": "cad/source/YUBI Gripper Assy_Dynamixel_ver2.STEP",
+  "cad_unit": "millimeter",
+  "mesh_unit": "meter",
+  "cad_origin_mm": [
+    854.070661629179,
+    856.5046236934521,
+    1286.5734593075358
+  ],
+  "cad_to_canonical_rotation": [
+    [
+      0,
+      0,
+      1
+    ],
+    [
+      1,
+      0,
+      0
+    ],
+    [
+      0,
+      1,
+      0
+    ]
+  ],
+  "cad_to_canonical_scale": 0.001,
+  "formula": "canonical_m = 0.001 * rotation @ (cad_mm - cad_origin_mm)",
+  "canonical_axes": {
+    "x": "+CAD Z, along parallel fingers",
+    "y": "+CAD X, toward source left jaw",
+    "z": "+CAD Y, hinge axis / camera side"
+  },
+  "bodies": {
+    "palm": {
+      "origin_m": [
+        0,
+        0,
+        0
+      ]
+    },
+    "left_jaw": {
+      "origin_m": [
+        -0.015999999999828787,
+        0.014999999999733518,
+        0.0
+      ],
+      "joint_axis": [
+        0,
+        0,
+        1
+      ],
+      "opening_angle_sign": 1,
+      "cad_neutral_joint_angle_rad": 0.0
+    },
+    "right_jaw": {
+      "origin_m": [
+        -0.01600000000017144,
+        -0.014999999999733518,
+        0.0
+      ],
+      "joint_axis": [
+        0,
+        0,
+        1
+      ],
+      "opening_angle_sign": -1,
+      "cad_neutral_joint_angle_rad": 0.0
+    }
+  },
+  "cad_neutral": "Parallel attachments point +canonical X; proven by paired flap mounting holes. This is a geometric reference, not a measured motor encoder zero.",
+  "calibration": {
+    "motor_zero_verified": false,
+    "robot_joint_limits_verified": false,
+    "nominal_glove_opening_range_rad": [
+      0.0,
+      0.94
+    ],
+    "nominal_range_warning": "Glove URDF range, not measured robot travel. CAD neutral already has a nonzero pad gap. Do not call q=0 fully closed."
+  },
+  "geometric_evidence": {
+    "right_jaw": {
+      "shaft_bore_radius_mm": 4.0,
+      "shaft_bore_center_mm": [
+        839.0706616294455,
+        862.5046236934472,
+        1270.5734593073644
+      ],
+      "shaft_axis_cad": [
+        0,
+        1,
+        0
+      ],
+      "flap_screw_centers_mm": [
+        [
+          834.0706616294581,
+          866.5046236934472,
+          1301.5734593073664
+        ],
+        [
+          834.0706616294653,
+          866.5046236934472,
+          1319.5734593073664
+        ]
+      ],
+      "flap_screw_spacing_mm": 18.0,
+      "finger_direction_cad": [
+        4.0421986745463475e-13,
+        0.0,
+        1.0
+      ]
+    },
+    "left_jaw": {
+      "shaft_bore_radius_mm": 4.0,
+      "shaft_bore_center_mm": [
+        869.0706616289125,
+        862.504623693457,
+        1270.573459307707
+      ],
+      "shaft_axis_cad": [
+        0,
+        1,
+        0
+      ],
+      "flap_screw_centers_mm": [
+        [
+          874.0706616289125,
+          866.504623693457,
+          1301.573459307707
+        ],
+        [
+          874.0706616289125,
+          866.504623693457,
+          1319.573459307707
+        ]
+      ],
+      "flap_screw_spacing_mm": 18.0,
+      "finger_direction_cad": [
+        0.0,
+        0.0,
+        1.0
+      ]
+    }
+  },
+  "optional_material_meshes": {
+    "palm": [
+      "cad_palm_camera.stl",
+      "cad_palm_servo.stl",
+      "cad_palm_structure.stl"
+    ],
+    "left_jaw": [
+      "cad_left_jaw_attachment.stl",
+      "cad_left_jaw_flap.stl",
+      "cad_left_jaw_hardware.stl",
+      "cad_left_jaw_pad.stl",
+      "cad_left_jaw_rubber.stl"
+    ],
+    "right_jaw": [
+      "cad_right_jaw_attachment.stl",
+      "cad_right_jaw_flap.stl",
+      "cad_right_jaw_hardware.stl",
+      "cad_right_jaw_pad.stl",
+      "cad_right_jaw_rubber.stl"
+    ]
+  }
+}