react-manip 0.1.0__py3-none-any.whl

scripts/verify_curling_reachability.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Diagnostic physical reachability through the unmodified evaluation action API.
+
+Calibration reads private geometry to construct witness actions. Frozen witnesses
+are then replayed by evaluate_policy.py without observation or environment access.
+This is NOT a learned-policy score, RGB perception test, or universal solvability
+certificate. It does not alter the shipped bank, physics, controls, or scoring.
+"""
+from copy import deepcopy
+from pathlib import Path
+import argparse
+import hashlib
+import json
+import os
+import subprocess
+import sys
+
+import numpy as np
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+from react_manip.core.scenarios import Scenario
+from react_manip.instances.candidate_bank import load_bank, copy_group, write_json
+from react_manip.instances.records import seal, save_record
+from react_manip.instances.runtime import ReplayEnv, runtime_identity, _construct
+from react_manip.robots.arm_actions import arm_action
+
+
+class FrozenWitnessPolicy:
+    policy_id = 'diagnostic-privileged-calibration-frozen-actions'
+
+    def __init__(self):
+        self.actions = np.asarray(json.loads(Path(os.environ['CURLING_WITNESS_ACTIONS']).read_text()))
+        if self.actions.ndim != 2 or not np.isfinite(self.actions).all() or np.any(np.abs(self.actions) > 1):
+            raise ValueError('Invalid frozen witness actions')
+        self.index = 0
+
+    def reset(self, **kwargs):
+        self.index = 0
+
+    def begin_episode(self, **kwargs):
+        self.reset()
+
+    def end_episode(self, **kwargs):
+        pass
+
+    def act(self, observation, info=None):
+        # Intentionally ignores observations, feedback, and private scene data.
+        if self.index >= len(self.actions):
+            raise RuntimeError('Witness exhausted before episode termination')
+        action = self.actions[self.index].copy()
+        self.index += 1
+        return action
+
+
+def rollout(env, strength):
+    env.reset()
+    raw = env.env
+    r = raw.robots[0]
+    arm = r.arms[0]
+    layout = r.composite_controller._action_split_indexes
+    c = r.part_controllers[arm]
+    assert c._goal_update_mode == 'achieved'
+    records = []
+    peak = 0.0
+    first = None
+    release = None
+    before = runtime_identity(env._wrapped if isinstance(env, ReplayEnv) else env, 'curling_push')
+
+    def step(delta):
+        nonlocal peak, first, release
+        a = arm_action(env.action_dim, layout, arm, np.r_[np.clip(np.array(delta) / raw.position_scale, -1, 1), np.zeros(3)], {arm: 1.0})
+        records.append(a.tolist())
+        (obs, _, term, trunc, info) = env.step(a)
+        peak = max(peak, float(raw.stone_velocity()[0]))
+        if raw._state.phase == 'pushing' and first is None:
+            first = float(raw.sim.data.time)
+        if raw._state.phase == 'sliding' and release is None:
+            release = dict(time=float(raw.sim.data.time), x=float(raw.stone_position()[0]), velocity=raw.stone_velocity().tolist())
+        return term or trunc
+    for goal in ([0.32, 0, 0.98], [0.32, 0, 0.71]):
+        for _ in range(700):
+            delta = np.array(goal) - raw.eef_pos()
+            if np.linalg.norm(delta) < 0.003:
+                break
+            if step(np.clip(delta, -0.01, 0.01)):
+                return (dict(score=0, info=raw._info(), stage='approach'), records)
+    for _ in range(100):
+        pos = raw.eef_pos()
+        delta = [strength, -pos[1], 0.71 - pos[2]]
+        if step(delta):
+            break
+        if raw.stone_position()[0] > 0.78 or (raw._state.last_contact is not None and raw.sim.data.time - raw._state.last_contact >= 0.01):
+            break
+    hold = raw.eef_pos().copy()
+    for _ in range(2600):
+        if raw._finished:
+            break
+        if step(hold - raw.eef_pos()):
+            break
+    assert c._goal_update_mode == 'achieved'
+    assert before == runtime_identity(env._wrapped if isinstance(env, ReplayEnv) else env, 'curling_push')
+    return (dict(strength=strength, score=raw._info()['task_score'], info=raw._info(), peak_speed=peak, stone=raw.stone_position().tolist(), release=release, steps=len(records)), records)
+
+
+def calibrate(env, out):
+    """Bounded privileged diagnostic search; only normal env.step moves bodies."""
+    parameters = env.env._parameters
+    target = parameters['target']['distance_m']
+    estimate = np.sqrt(2 * parameters['ice']['friction'] * 9.81 * (target - .55)) / 6.4
+    trials = []
+    for offset in (0, .005, -.005, .01, -.01, .02, -.02):
+        trial, actions = rollout(env, float(np.clip(estimate + offset, .015, .15)))
+        trials.append(trial)
+        print(json.dumps(dict(case=out.name, **trial)), flush=True)
+        write_json(out / 'calibration.json', trials)
+        if trial['score'] == 100:
+            write_json(out / 'actions.json', actions)
+            return trial
+    raise RuntimeError(f'No witness found in bounded search for {out.name}; this alone does not prove impossibility')
+
+
+def replay_cli(out, arguments, expected_episodes):
+    result_path = out / 'evaluation.json'
+    command = [sys.executable, str(ROOT / 'scripts/evaluate_policy.py'), *arguments,
+               '--state-only-smoke', '--policy',
+               'scripts.verify_curling_reachability:FrozenWitnessPolicy', '--out', str(result_path)]
+    environment = dict(os.environ, CURLING_WITNESS_ACTIONS=str((out / 'actions.json').resolve()))
+    with (out / 'evaluation.log').open('w') as log:
+        subprocess.run(command, cwd=ROOT, env=environment, stdout=log, stderr=subprocess.STDOUT, check=True)
+    result = json.loads(result_path.read_text())
+    rows = result['episodes']
+    if not result.get('valid', True) or len(rows) != expected_episodes:
+        raise RuntimeError(f'Invalid evaluation for {out.name}')
+    if any(row.get('error') or row.get('episode_score') != 100 for row in rows):
+        raise RuntimeError(f'Frozen witness failed in evaluator for {out.name}')
+    print(f'{out.name}: {len(rows)} evaluator replays passed', flush=True)
+    return dict(episodes=len(rows), all_scores_100=True, command=command,
+                observation_mode='state_only_smoke', official_score=None)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--bank', type=Path, default=ROOT / 'react_manip/suites/piperx_candidates_v1/bank.json')
+    parser.add_argument('--out', type=Path, required=True, help='New diagnostic output directory')
+    args = parser.parse_args(argv)
+    out = args.out.resolve()
+    out.mkdir(parents=True, exist_ok=False)
+    bank, source, manifest, groups = load_bank(args.bank)
+    report = dict(bank_digest=bank['content_digest'],
+                  script_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+                  scope='Unmodified action API and physics; privileged calibration followed by blind action replay',
+                  limitations=['Not a learned-model or RGB perception evaluation',
+                               'Only saved candidates and four mass/distance corners; not every point in the parameter continuum',
+                               'Each candidate has 15 identical initial states; repetition checks evaluator compatibility, not 15 distinct scenarios'],
+                  candidates=[], boundaries=[], completed=False)
+    write_json(out / 'report.json', report)
+    for instance, episodes in groups['curling_push']:
+        name = instance['task_instance_id']
+        directory = out / name
+        directory.mkdir()
+        group = next(g for g in manifest['groups'] if g['task_instance']['digest'] == instance['content_digest'])
+        copy_group(group, source.parent, directory)
+        subset = seal('manifest', suite_id='diagnostic_' + name, protocol=manifest['protocol'], groups=[group])
+        save_record(subset, directory / 'manifest.json')
+        env = ReplayEnv(instance, cameras=False)
+        try:
+            env.bind(episodes[0])
+            witness = calibrate(env, directory)
+        finally:
+            env.close()
+        replay = replay_cli(directory, ['--manifest', str(directory / 'manifest.json')], len(episodes))
+        p = instance['scenario']['parameters']
+        report['candidates'].append(dict(task_instance_id=name, mass_kg=p['stone']['mass_kg'],
+                                         target_m=p['target']['distance_m'], witness=witness, replay=replay))
+        write_json(out / 'report.json', report)
+    base = groups['curling_push'][0][0]['scenario']
+    for mass in (1., 10.):
+        for target in (1., 5.):
+            name = f'boundary_mass_{mass:g}_target_{target:g}'
+            directory = out / name
+            directory.mkdir()
+            data = deepcopy(base)
+            data.pop('digest')
+            data['scenario_id'] = name
+            data['parameters']['stone']['mass_kg'] = mass
+            data['parameters']['target']['distance_m'] = target
+            scenario = Scenario(**data)
+            scenario.save(directory / 'scenario.json')
+            env = _construct('curling_push', scenario, 'piperx')
+            try:
+                witness = calibrate(env, directory)
+            finally:
+                env.close()
+            replay = replay_cli(directory, ['--task', 'curling_push', '--scenario',
+                                            str(directory / 'scenario.json')], 15)
+            report['boundaries'].append(dict(mass_kg=mass, target_m=target, witness=witness, replay=replay))
+            write_json(out / 'report.json', report)
+    report['completed'] = True
+    report['verified_evaluator_episodes'] = sum(r['replay']['episodes'] for r in report['candidates'] + report['boundaries'])
+    write_json(out / 'report.json', report)
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

scripts/verify_piperx_tasks.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Reset/step physical task combinations and verify compiled gripper surfaces.
+
+This is a smoke check, not a success-rate evaluation or replacement for a
+new candidate bank. Output records include each task/embodiment separately.
+"""
+from pathlib import Path
+import argparse
+import json
+import sys
+import traceback
+import numpy as np
+ROOT=Path(__file__).resolve().parents[1]
+sys.path.insert(0,str(ROOT))
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--robots',nargs='+',default=['piperx','dual_piperx','mobile_dual_piperx'])
+    p.add_argument('--tasks',nargs='+')
+    p.add_argument('--steps',type=int,default=5)
+    p.add_argument('--mobile-vx',type=float,default=.1)
+    p.add_argument('--mobile-wz',type=float,default=0.)
+    p.add_argument('--out',type=Path,default=ROOT/'outputs/piperx_task_smoke.json')
+    args=p.parse_args()
+    from react_manip import register_builtin_tasks
+    from react_manip.core.registry import get_task_registry
+    from react_manip.robots.agilex_robosuite import validate_compiled_grippers
+    from react_manip.robots.mobile_base import set_wheel_command
+    from react_manip.core.scenarios import sample_scenario
+    register_builtin_tasks()
+    rows=[]
+    for definition in get_task_registry().list():
+        task=definition.spec.task_id
+        if args.tasks and task not in args.tasks:continue
+        for robot in args.robots:
+            if not definition.spec.supports_robot(robot):continue
+            env=None;row=dict(task=task,robot=robot)
+            try:
+                kwargs=dict(seed=0,robot_id=robot,has_offscreen_renderer=False)
+                if task=='button_indicator_matching':
+                    profile=json.loads((ROOT/'configs'/task/'profile_default.json').read_text())
+                    kwargs['scenario']=sample_scenario(profile,seed=0)
+                env=definition.factory(**kwargs)
+                env.reset()
+                raw=getattr(env,'env',env)
+                validate_compiled_grippers(env)
+                model,data=raw.sim.model,raw.sim.data
+                start_root=np.asarray(data.body_xpos[model.body_name2id('robot0_base')]).copy() if robot in ('mobile_dual_piperx','aloha_mobile') else np.zeros(3)
+                max_tilt=0.
+                for _ in range(args.steps):
+                    if robot in ('mobile_dual_piperx','aloha_mobile'):
+                        command = getattr(raw, 'set_mobile_base_command', None)
+                        if command is not None:
+                            command(args.mobile_vx, args.mobile_wz)
+                        else:
+                            set_wheel_command(raw, args.mobile_vx, args.mobile_wz)
+                    env.step(np.zeros(raw.action_dim))
+                    if robot in ('mobile_dual_piperx','aloha_mobile'):
+                        root=model.body_name2id('robot0_base')
+                        max_tilt=max(max_tilt,float(np.arccos(np.clip(data.body_xmat[root].reshape(3,3)[2,2],-1,1))))
+                validate_compiled_grippers(env)
+                if not np.isfinite(data.qpos).all() or not np.isfinite(data.qvel).all():
+                    raise ValueError('Nonfinite state')
+                if np.max(np.abs(data.qvel))>1000:raise ValueError('Unstable velocities')
+                if robot in ('mobile_dual_piperx','aloha_mobile'):
+                    root=model.body_name2id('robot0_base')
+                    row.update(root_displacement_m=float(np.linalg.norm(data.body_xpos[root,:2]-start_root[:2])),max_tilt_rad=max_tilt)
+                    if max_tilt>.35:raise ValueError('Mobile chassis tilted more than 20 degrees')
+                row.update(passed=True,action_dim=int(raw.action_dim),ngeom=int(model.ngeom),max_speed=float(np.abs(data.qvel).max()))
+            except Exception as exc:
+                row.update(passed=False,error=f'{type(exc).__name__}: {exc}')
+                traceback.print_exc()
+            finally:
+                if env is not None:env.close()
+            rows.append(row);print(json.dumps(row),flush=True)
+            args.out.parent.mkdir(parents=True,exist_ok=True)
+            args.out.write_text(json.dumps(rows,indent=2)+'\n')
+    return int(not rows or any(not r['passed'] for r in rows))
+
+if __name__=='__main__':raise SystemExit(main())

tasks/box_insertion/__init__.py

@@ -0,0 +1,3 @@
+"""Imported box-insertion asset task."""
+from .env import BoxInsertion
+__all__ = ["BoxInsertion"]

tasks/box_insertion/assets/scene.xml

@@ -0,0 +1,50 @@
+<?xml version='1.0' encoding='utf-8'?>
+<mujoco model="box_insertion">
+  <option timestep="0.002" gravity="0 0 -9.81" integrator="implicitfast" />
+  <asset>
+    <material name="table_mat" rgba="0.42 0.25 0.12 1" />
+    <material name="box_mat" rgba="0.12 0.15 0.18 1" />
+    <material name="block_mat" rgba="0.72 0.42 0.16 1" />
+  </asset>
+  <worldbody>
+    <geom name="floor" type="plane" pos="0 0 0" size="3 3 0.1" friction="0.6 0.01 0.001" />
+    <!-- Worktable spans x=[-0.20, 0.70] and y=[-0.80, 0.80]. The extra
+         lateral room supports the sampled 0.60 to 1.00 m block and its
+         width-plus-0.05 m slot opening. The arena resizes these geoms per
+         Scenario before MuJoCo compilation. -->
+    <geom name="table" type="box" pos="0.25 0 0.755" size="0.45 0.80 0.025" material="table_mat" group="1" friction="0.005 0.01 0.001" />
+    <geom name="table_leg_nx_py" type="box" pos="-0.14 0.74 0.3775" size="0.035 0.035 0.3775" material="table_mat" group="1" />
+    <geom name="table_leg_nx_ny" type="box" pos="-0.14 -0.74 0.3775" size="0.035 0.035 0.3775" material="table_mat" group="1" />
+    <geom name="table_leg_px_py" type="box" pos="0.64 0.74 0.3775" size="0.035 0.035 0.3775" material="table_mat" group="1" />
+    <geom name="table_leg_px_ny" type="box" pos="0.64 -0.74 0.3775" size="0.035 0.035 0.3775" material="table_mat" group="1" />
+    <!-- A joint-free body is welded to the world at the tabletop. There is
+         intentionally no slot floor: the same table geom supports the block
+         both outside and inside the fixture, so no threshold step exists. -->
+    <body name="slot_fixture" pos="0.26 0 0.78">
+      <!-- Slot walls override block friction. Values below are legacy
+           fallbacks; the arena applies sampled side/back wall coefficients. -->
+      <geom name="box_back" type="box" pos="0.15 0 0.035" size="0.01 0.545 0.035" material="box_mat" group="1" rgba="0.10 0.16 0.24 1" priority="1" friction="0.02 0.002 0.0001" />
+      <geom name="box_left" type="box" pos="0 -0.535 0.035" size="0.16 0.01 0.035" material="box_mat" group="1" rgba="0.10 0.16 0.24 1" priority="1" friction="3.0 0.02 0.001" />
+      <geom name="box_right" type="box" pos="0 0.535 0.035" size="0.16 0.01 0.035" material="box_mat" group="1" rgba="0.10 0.16 0.24 1" priority="1" friction="3.0 0.02 0.001" />
+    </body>
+    <!-- Invisible reference site used by geometry observations; it is not a
+         physical object and must not look like a second insertion block. -->
+    <site name="box_entry" type="box" pos="0.10 0 0.80" size="0.008 0.525 0.045" rgba="0 0 0 0" />
+    <site name="box_bottom_target" type="sphere" pos="0.334125 0 0.802107" size="0.004" rgba="0 0 0 0" />
+    <camera name="overview" pos="-1.00 -1.80 1.50" fovy="55" xyaxes="0.843 -0.538 0 0.172 0.270 0.949" />
+    <camera name="boxview" pos="-0.45 -1.50 1.05" fovy="55" xyaxes="0.917 -0.398 0 0.060 0.139 0.989" />
+    <body name="wood_block" pos="-0.02587494622388665 0.0 0.8021071570474048">
+      <!-- At reset the block spans x=[-0.092, 0.040], leaving 0.06 m before
+           the slot entrance at x=0.10. A free joint lets gravity generate the
+           table normal load and therefore genuine Coulomb friction. -->
+      <freejoint name="block_free" />
+      <!-- One rigid body with two collision regions across local Y. Their
+           shared boundary is resized from the sampled Scenario before model
+           compilation. Sampled regional densities determine the body's
+           total mass, center of mass and inertia; defaults below are legacy. -->
+      <geom name="block_contact_left" type="box" pos="0 -0.25 0" size="0.065875 0.25 0.022107" density="650" group="0" rgba="0 0 0 0" friction="0.10 0.01 0.001" />
+      <geom name="block_contact_right" type="box" pos="0 0.25 0" size="0.065875 0.25 0.022107" density="650" group="0" rgba="0 0 0 0" friction="0.10 0.01 0.001" />
+      <geom name="block_visual" type="box" size="0.065875 0.50 0.022107" material="block_mat" group="1" contype="0" conaffinity="0" mass="0" />
+    </body>
+  </worldbody>
+</mujoco>