assests / common /source /starBenchserver /benchmarks /simBenchmarks /DOMINO /checks /test_contract.py
| """Offline contract/ordering checks; no native simulator or model dependencies.""" | |
| from contextlib import nullcontext | |
| from copy import deepcopy | |
| from pathlib import Path | |
| from tempfile import TemporaryDirectory | |
| from types import SimpleNamespace | |
| import itertools | |
| import math | |
| import struct | |
| import unittest | |
| from unittest.mock import patch, Mock | |
| import numpy as np | |
| from benchmarks.simBenchmarks.DOMINO.bench_server.adapter import ( | |
| DOMINOBenchmarkAdapter, DOMINOEpisode, make_domino, policy_observation, | |
| ) | |
| from benchmarks.simBenchmarks.DOMINO.bench_server.protocol import CAMERAS, IMAGE_SHAPE, JOINT_NAMES, NATIVE_HORIZON | |
| from benchmarks.simBenchmarks.DOMINO.environment.native_outcome import NativeOutcome | |
| from benchmarks.simBenchmarks.DOMINO.environment.deployment import ( | |
| digest, inventory, verify_rows, expand_asset_root_template, verify_curobo_asset_paths, | |
| ) | |
| from benchmarks.simBenchmarks.DOMINO.environment.runtime import SceneStepCounter, verify_compiled | |
| from benchkit.errors import CompatibilityError | |
| from benchkit.sim_server.server import BenchmarkService | |
| def adapter(**overrides): | |
| values = dict(source_root="/native/domino", deployment_manifest_sha256="a" * 64, | |
| episode_manifest="/private/manifest.pkl", episode_manifest_sha256="b" * 64) | |
| values.update(overrides) | |
| return DOMINOBenchmarkAdapter(**values) | |
| class Tracker: | |
| def __init__(self, env, config): | |
| self.env, self.steps, self.bounds = env, 0, 0 | |
| def on_episode_start(self): | |
| self.env.events.append("tracker_start") | |
| def on_step(self): | |
| self.steps += 1 | |
| self.env.events.append("metrics_step") | |
| def record_out_of_bounds(self): | |
| self.bounds += 1 | |
| self.env.events.append("out_of_bounds_penalty") | |
| def get_episode_metrics(self, success, fail_reason, seed): | |
| return SimpleNamespace(success=success, fail_reason=fail_reason, steps_taken=self.steps, | |
| max_steps=400, route_completion=100 if success else 0, | |
| manipulation_score=100 if success else 0, | |
| total_penalty_factor=0.5 if self.bounds else 1, penalty_events=[]) | |
| class Env: | |
| def __init__(self, *, dynamic=True, success=False, fail=False, contact=False, | |
| stopped=False, boundary=True, stop_on_contact=True, z=None, horizon=False): | |
| self.events = [] | |
| self.use_dynamic, self.eval_success, self.eval_fail = dynamic, success, fail | |
| self.contact, self._dynamic_object_stopped, self.boundary = contact, stopped, boundary | |
| self.take_action_cnt, self.step_lim = (400 if horizon else 1), 400 | |
| self.position = 0.0 | |
| actor = SimpleNamespace(get_pose=lambda: SimpleNamespace(p=[0, 0, self.position])) | |
| self.config = {"target_actor": actor, "stop_on_contact": stop_on_contact} | |
| if z is not None: | |
| self.config["check_z_threshold"] = 0.1 | |
| def get_dynamic_motion_config(self): | |
| return self.config if self.use_dynamic else None | |
| def check_gripper_contact_dynamic_object(self): | |
| self.events.append("contact") | |
| return self.contact | |
| def stop_dynamic_object_motion(self): | |
| self.events.append("stop_motion") | |
| self._dynamic_object_stopped = True | |
| def check_dynamic_object_boundary(self): | |
| self.events.append("boundary") | |
| return self.boundary | |
| def native_reference_checks(env, threshold, actor, start_z, stop_on_contact, tracker): | |
| """Independent transcription of pinned eval_policy.py:352-383. | |
| No service wrapper calls this oracle. Return models break / next iteration. | |
| Native take_action's metrics_step has already occurred before this block. | |
| """ | |
| has_lifted = False | |
| if threshold is not None and not has_lifted: | |
| curr_z = actor.get_pose().p[2] | |
| if curr_z - start_z > threshold: | |
| has_lifted = True | |
| if env.eval_success: | |
| if threshold is not None and not has_lifted: | |
| return False, "object_not_lifted", True | |
| return True, None, True | |
| out_of_bounds = False | |
| if env.use_dynamic: | |
| if env.check_gripper_contact_dynamic_object() and stop_on_contact: | |
| env.stop_dynamic_object_motion() | |
| if not getattr(env, "_dynamic_object_stopped", False): | |
| if not env.check_dynamic_object_boundary(): | |
| env.eval_fail = True | |
| out_of_bounds = True | |
| if out_of_bounds: | |
| tracker.record_out_of_bounds() | |
| return False, "out_of_bounds", True | |
| if env.eval_fail: | |
| return False, "eval_fail", True | |
| return False, None, env.take_action_cnt >= env.step_lim | |
| class NativeParityTests(unittest.TestCase): | |
| def test_native_asset_root_substitutions_keep_single_assets_suffix(self): | |
| root = Path("/owned/domino") | |
| template = "urdf: ${ASSETS_PATH}/assets/robot.urdf\ncollision: $ASSETS_PATH/assets/collision.yml\nagain: ${ASSETS_PATH}/assets/mesh.obj\n" | |
| expected = "urdf: /owned/domino/assets/robot.urdf\ncollision: /owned/domino/assets/collision.yml\nagain: /owned/domino/assets/mesh.obj\n" | |
| self.assertEqual(expand_asset_root_template(template, root), expected) | |
| with self.assertRaises(ValueError): | |
| expand_asset_root_template("bare ASSETS_PATH is not the native token", root) | |
| with self.assertRaises(ValueError): | |
| expand_asset_root_template(template, Path("relative")) | |
| def test_materialized_curobo_paths_fail_before_native_import(self): | |
| with TemporaryDirectory() as tmp: | |
| root = Path(tmp) | |
| (root / "assets").mkdir() | |
| urdf, collision = root / "assets/robot.urdf", root / "assets/collision.yml" | |
| urdf.write_text("<robot/>") | |
| collision.write_text("collision_spheres: {}") | |
| config = {"robot_cfg": {"kinematics": {"urdf_path": str(urdf), "collision_spheres": str(collision)}}} | |
| self.assertEqual(verify_curobo_asset_paths(root, config)["urdf_path"], str(urdf)) | |
| for value in ("${/wrong/assets}/assets/robot.urdf", "assets/robot.urdf", str(root / "missing.urdf")): | |
| invalid = deepcopy(config) | |
| invalid["robot_cfg"]["kinematics"]["urdf_path"] = value | |
| with self.subTest(value=value), self.assertRaises(ValueError): | |
| verify_curobo_asset_paths(root, invalid) | |
| def test_post_action_native_order_matrix(self): | |
| names = ("dynamic", "success", "fail", "contact", "stopped", "boundary", "stop_on_contact", "horizon") | |
| for flags in itertools.product((False, True), repeat=len(names)): | |
| for z in (None, 0.05, 0.2): | |
| values = dict(zip(names, flags), z=z) | |
| with self.subTest(**values): | |
| env = Env(**values) | |
| reference = Env(**values) | |
| outcome = NativeOutcome(env, {}, Tracker) | |
| reference_tracker = Tracker(reference, {}) | |
| reference_tracker.on_episode_start() | |
| env.position = reference.position = z or 0 | |
| outcome.tracker.on_step() # Native take_action already does this. | |
| reference_tracker.on_step() | |
| config = reference.get_dynamic_motion_config() | |
| threshold = config.get("check_z_threshold") if config else None | |
| actor = config["target_actor"] if config else None | |
| expected = native_reference_checks(reference, threshold, actor, 0, | |
| values["stop_on_contact"], reference_tracker) | |
| outcome.after_action() | |
| self.assertEqual((outcome.success, outcome.fail_reason, outcome.finished), expected) | |
| self.assertEqual(env.events, reference.events) | |
| self.assertEqual(outcome.tracker.steps, 1) # No wrapper double-count. | |
| self.assertEqual(outcome.tracker.bounds, reference_tracker.bounds) | |
| def test_check_z_actor_does_not_evaluate_missing_target_actor(self): | |
| env = Env(z=0.2, success=True) | |
| env.config["check_z_actor"] = env.config.pop("target_actor") | |
| result = NativeOutcome(env, {}, Tracker) | |
| env.position = 0.2 | |
| result.after_action() | |
| self.assertTrue(result.success) | |
| def test_lift_memory_persists_between_controls(self): | |
| env = Env(z=0.2) | |
| outcome = NativeOutcome(env, {}, Tracker) | |
| env.position = 0.2 | |
| outcome.after_action() | |
| env.position, env.eval_success = 0, True | |
| outcome.after_action() | |
| self.assertTrue(outcome.success) | |
| class CompiledTimestepTests(unittest.TestCase): | |
| def environment(timestep): | |
| joints = [SimpleNamespace(get_name=Mock(return_value=name)) for name in JOINT_NAMES] | |
| return SimpleNamespace( | |
| robot=SimpleNamespace(left_arm_joints=joints[:6], right_arm_joints=joints[6:]), | |
| scene=SimpleNamespace(get_timestep=Mock(return_value=timestep), set_timestep=Mock(), step=Mock()), | |
| step_lim=NATIVE_HORIZON, take_action_cnt=0, setup_demo=Mock(), take_action=Mock()) | |
| def test_exact_and_native_float32_timestep_pass_without_native_mutation(self): | |
| rounded = struct.unpack("!f", struct.pack("!f", 1 / 250))[0] | |
| self.assertEqual(rounded, 0.004000000189989805) | |
| # This is the original initialization defect, reproduced without SAPIEN. | |
| self.assertFalse(math.isclose(rounded, 1 / 250, abs_tol=1e-10)) | |
| for timestep in (1 / 250, rounded, np.float32(1 / 250)): | |
| with self.subTest(timestep=timestep): | |
| env = self.environment(timestep) | |
| self.assertEqual(verify_compiled(env), { | |
| "joint_names": list(JOINT_NAMES), "physics_timestep_s": 1 / 250, | |
| "action_type": "qpos", "native_horizon": NATIVE_HORIZON, | |
| "ticks_per_control": "variable native TOPP interpolation"}) | |
| env.scene.get_timestep.assert_called_once_with() | |
| for method in (env.scene.set_timestep, env.scene.step, env.setup_demo, env.take_action): | |
| method.assert_not_called() | |
| self.assertEqual((env.step_lim, env.take_action_cnt), (400, 0)) | |
| def test_half_binary32_ulp_boundary_is_not_a_general_frequency_tolerance(self): | |
| # At 0.004 the binary32 spacing is 2^-31; half is exactly 2^-32. | |
| lower, upper = 1 / 250 - 2**-32, 1 / 250 + 2**-32 | |
| for timestep in (lower, upper): | |
| with self.subTest(boundary=timestep): | |
| verify_compiled(self.environment(timestep)) | |
| for timestep in (math.nextafter(lower, -math.inf), math.nextafter(upper, math.inf)): | |
| with self.subTest(outside=timestep), self.assertRaises(CompatibilityError): | |
| verify_compiled(self.environment(timestep)) | |
| def test_adjacent_float32_values_and_invalid_timesteps_still_fail(self): | |
| bits = struct.unpack("!I", struct.pack("!f", 1 / 250))[0] | |
| adjacent = tuple(struct.unpack("!f", struct.pack("!I", bits + delta))[0] for delta in (-1, 1)) | |
| for timestep in (*adjacent, 1 / 240, 1 / 251, 0.0, -1 / 250, True, False, | |
| float("nan"), float("inf"), -float("inf")): | |
| with self.subTest(timestep=timestep), self.assertRaises(CompatibilityError): | |
| verify_compiled(self.environment(timestep)) | |
| def test_other_compiled_contract_guards_are_unchanged(self): | |
| rounded = struct.unpack("!f", struct.pack("!f", 1 / 250))[0] | |
| cases = ("joint_order", "horizon", "started_control") | |
| for case in cases: | |
| env = self.environment(rounded) | |
| if case == "joint_order": | |
| env.robot.left_arm_joints[0].get_name.return_value = "wrong_joint" | |
| elif case == "horizon": | |
| env.step_lim += 1 | |
| else: | |
| env.take_action_cnt = 1 | |
| with self.subTest(case=case), self.assertRaises(CompatibilityError): | |
| verify_compiled(env) | |
| class ContractTests(unittest.TestCase): | |
| def test_service_describe_exposes_native_cap_without_reset(self): | |
| with TemporaryDirectory() as directory: | |
| value = adapter() | |
| service = BenchmarkService(value, root=Path(directory) / "service", seed=0) | |
| self.assertEqual(service.description["budget"]["environment_step_cap"], 400) | |
| self.assertEqual(service.description["budget"]["required_replan_interval"], 1) | |
| self.assertFalse(value.claimed) | |
| def test_construct_and_schedule_do_not_read_native_files(self): | |
| value = adapter() | |
| self.assertEqual(value.descriptor.name, "domino") | |
| self.assertEqual(value.required_replan_interval, 1) | |
| self.assertEqual(value.episodes(0)[0].metadata["native_horizon"], 400) | |
| session = value.open_episode(value.episodes(0)[0]) | |
| self.assertFalse(session.reset_attempted) | |
| with self.assertRaises(Exception): | |
| value.open_episode(value.episodes(0)[0]) | |
| def test_parameters_reject_unsupported_tracks(self): | |
| for values in ({"task": "lift_pot"}, {"evaluation_mode": "full"}, | |
| {"native_seed": True}, {"source_root": "relative"}, | |
| {"episode_manifest_sha256": "no"}): | |
| with self.subTest(**values), self.assertRaises(ValueError): | |
| adapter(**values) | |
| with self.assertRaises(ValueError): | |
| make_domino({"expert": True}) | |
| def test_no_added_motion_or_joint_guard(self): | |
| spec = adapter().action_spec | |
| self.assertIsNone(spec.low) | |
| self.assertEqual(spec.validate([12345.] * 14), (12345.,) * 14) | |
| for values in ([0.] * 13, [False] * 14, [float("nan")] * 14): | |
| with self.assertRaises((ValueError, TypeError)): | |
| spec.validate(values) | |
| def test_public_allowlist_and_copy(self): | |
| raw = {"observation": {camera: {"rgb": np.zeros(IMAGE_SHAPE, np.uint8), "object_pose": "secret"} | |
| for camera in CAMERAS}, | |
| "joint_action": {"vector": np.arange(14, dtype=float)}, | |
| "score": 100, "dynamic_motion_info": "secret"} | |
| result = policy_observation(raw, 0) | |
| self.assertEqual(result.state, tuple(float(i) for i in range(14))) | |
| self.assertEqual(set(result.images), set(CAMERAS)) | |
| self.assertNotIn("secret", str(result.log_view())) | |
| raw["observation"][CAMERAS[0]]["rgb"][0, 0, 0] = 255 | |
| self.assertEqual(result.images[CAMERAS[0]][0, 0, 0], 0) | |
| self.assertTrue(all(name.startswith("commanded_target_") for name in adapter().observation_spec.state_names)) | |
| def test_bad_native_state_and_images_fail_closed(self): | |
| for bad in (None, [0.] * 13, [float("nan")] * 14, [True] * 14): | |
| raw = {"observation": {c: {"rgb": np.zeros(IMAGE_SHAPE, np.uint8)} for c in CAMERAS}, | |
| "joint_action": {"vector": bad}} | |
| with self.assertRaises((ValueError, TypeError, RuntimeError)): | |
| policy_observation(raw, 0) | |
| def test_early_diagnostic_not_completed_native_score(self): | |
| value = adapter() | |
| session = DOMINOEpisode(value, value.episodes(0)[0]) | |
| self.assertFalse(session.metrics()["native_score_complete"]) | |
| session.native_terminal = True | |
| self.assertTrue(session.metrics()["native_score_complete"]) | |
| session.control_error = True | |
| self.assertFalse(session.metrics()["native_score_complete"]) | |
| def test_ack_control_physics_and_native_metrics_counts(self): | |
| value = adapter() | |
| session = DOMINOEpisode(value, value.episodes(0)[0]) | |
| env = Env() | |
| env.take_action_cnt = 0 | |
| env.scene = SimpleNamespace(step=lambda: None) | |
| session.counter = SceneStepCounter(env.scene) | |
| env.scene = session.counter | |
| raw = {"observation": {c: {"rgb": np.zeros(IMAGE_SHAPE, np.uint8)} for c in CAMERAS}, | |
| "joint_action": {"vector": np.zeros(14)}} | |
| env.get_obs = lambda: raw | |
| received = [] | |
| def take_action(values, action_type): | |
| received.append((values, action_type)) | |
| env.take_action_cnt += 1 | |
| for _ in range(3): | |
| env.scene.step() | |
| env._metrics_tracker.on_step() | |
| env.take_action = take_action | |
| session.env = env | |
| session.outcome = NativeOutcome(env, {}, Tracker) | |
| session.reset_completed = True | |
| session.cache = Path("/owned/cache") | |
| with patch("benchmarks.simBenchmarks.DOMINO.environment.runtime.native_directory", return_value=nullcontext()): | |
| result = session.step([12345.] * 14) | |
| self.assertEqual(received, [((12345.,) * 14, "qpos")]) | |
| self.assertEqual((session.step_count, session.native_steps, session.acknowledged_controls, session.physics_ticks), (1, 1, 1, 3)) | |
| self.assertEqual(session.outcome.tracker.steps, 1) | |
| self.assertFalse(result.terminated) | |
| self.assertFalse(session.metrics()["native_score_complete"]) | |
| with self.assertRaises(ValueError): | |
| session.step([0.] * 13) | |
| self.assertEqual(len(received), 1) | |
| def test_native_error_is_not_replayed(self): | |
| value = adapter() | |
| session = DOMINOEpisode(value, value.episodes(0)[0]) | |
| env = Env() | |
| env.take_action_cnt = 0 | |
| session.counter = SceneStepCounter(SimpleNamespace(step=lambda: None)) | |
| session.env, session.reset_completed, session.cache = env, True, Path("/owned/cache") | |
| def fail(values, action_type): | |
| env.take_action_cnt += 1 | |
| raise RuntimeError("uncertain native action") | |
| env.take_action = fail | |
| with patch("benchmarks.simBenchmarks.DOMINO.environment.runtime.native_directory", return_value=nullcontext()): | |
| with self.assertRaises(RuntimeError): | |
| session.step([0.] * 14) | |
| with self.assertRaises(RuntimeError): | |
| session.step([0.] * 14) | |
| self.assertEqual((session.native_steps, session.acknowledged_controls), (1, 0)) | |
| self.assertTrue(session.control_error) | |
| self.assertFalse(session.metrics()["native_score_complete"]) | |
| def test_bad_derived_config_does_not_import_or_instantiate_native(self): | |
| value = adapter() | |
| session = value.open_episode(value.episodes(0)[0]) | |
| prefix = "benchmarks.simBenchmarks.DOMINO.environment.runtime." | |
| with TemporaryDirectory() as directory: | |
| session.bind_artifact_dir(Path(directory)) | |
| with patch(prefix + "native_directory", return_value=nullcontext()), \ | |
| patch(prefix + "readiness", return_value={}), \ | |
| patch(prefix + "resolved_config", side_effect=ValueError("invalid asset path")), \ | |
| patch(prefix + "import_native") as imported: | |
| with self.assertRaisesRegex(ValueError, "invalid asset path"): | |
| session.reset() | |
| imported.assert_not_called() | |
| self.assertFalse(session.reset_completed) | |
| self.assertEqual(session.acknowledged_controls, 0) | |
| def test_partial_reset_failure_cleanup_is_once(self): | |
| value = adapter() | |
| session = DOMINOEpisode(value, value.episodes(0)[0]) | |
| env = SimpleNamespace(setup_demo=Mock(side_effect=RuntimeError("partial reset failed")), | |
| close_env=Mock(), release_episode_resources=Mock()) | |
| prefix = "benchmarks.simBenchmarks.DOMINO.environment.runtime." | |
| with TemporaryDirectory() as directory: | |
| session.bind_artifact_dir(Path(directory)) | |
| with patch(prefix + "native_directory", return_value=nullcontext()), \ | |
| patch(prefix + "readiness", return_value={}), \ | |
| patch(prefix + "import_native", return_value=(lambda: env, Tracker, object)), \ | |
| patch(prefix + "resolved_config", return_value={}), \ | |
| patch(prefix + "load_entry", return_value={"dynamic_motion_info": {}}): | |
| with self.assertRaisesRegex(RuntimeError, "partial reset failed"): | |
| session.reset() | |
| session.close() | |
| with self.assertRaises(RuntimeError): | |
| session.reset() | |
| env.close_env.assert_called_once() | |
| env.release_episode_resources.assert_called_once() | |
| self.assertFalse(session.reset_completed) | |
| self.assertEqual(session.acknowledged_controls, 0) | |
| def test_full_mocked_reset_two_controls_close(self): | |
| value = adapter() | |
| session = value.open_episode(value.episodes(0)[0]) | |
| env = Env() | |
| env.take_action_cnt = 0 | |
| env.scene = SimpleNamespace(step=lambda: None) | |
| env.setup_demo = Mock() | |
| env.set_instruction = Mock() | |
| env.init_dynamic_motion_for_eval = Mock(return_value=True) | |
| env.close_env, env.release_episode_resources = Mock(), Mock() | |
| raw = {"observation": {c: {"rgb": np.zeros(IMAGE_SHAPE, np.uint8)} for c in CAMERAS}, | |
| "joint_action": {"vector": np.zeros(14)}} | |
| def control(values, action_type): | |
| env.take_action_cnt += 1 | |
| for _ in range(3): | |
| env.scene.step() | |
| env._metrics_tracker.on_step() | |
| env.take_action = Mock(side_effect=control) | |
| prefix = "benchmarks.simBenchmarks.DOMINO.environment.runtime." | |
| with TemporaryDirectory() as directory: | |
| session.bind_artifact_dir(Path(directory)) | |
| with patch(prefix + "native_directory", return_value=nullcontext()), \ | |
| patch(prefix + "readiness", return_value={}), \ | |
| patch(prefix + "import_native", return_value=(lambda: env, Tracker, object)), \ | |
| patch(prefix + "resolved_config", return_value={}), \ | |
| patch(prefix + "load_entry", return_value={"dynamic_motion_info": {"private": "motion"}}), \ | |
| patch(prefix + "verify_compiled", return_value={}), \ | |
| patch(prefix + "verify_loaded_renderer", return_value=[]), \ | |
| patch.object(session, "_observe", side_effect=lambda: policy_observation(raw, session.step_count)): | |
| self.assertEqual(session.reset().step, 0) | |
| self.assertEqual(session.step([0.] * 14).observation.step, 1) | |
| self.assertEqual(session.step([0.] * 14).observation.step, 2) | |
| self.assertEqual(session.outcome.tracker.steps, 2) | |
| self.assertEqual((session.native_steps, session.acknowledged_controls, session.physics_ticks), (2, 2, 6)) | |
| self.assertFalse(session.metrics()["native_score_complete"]) | |
| session.artifacts() | |
| session.close() | |
| session.close() | |
| env.setup_demo.assert_called_once() | |
| env.init_dynamic_motion_for_eval.assert_called_once() | |
| self.assertEqual(env.take_action.call_count, 2) | |
| env.close_env.assert_called_once() | |
| env.release_episode_resources.assert_called_once() | |
| self.assertTrue((Path(directory) / "native_cleanup.json").is_file()) | |
| def test_release_runs_after_close_error_and_is_not_repeated(self): | |
| value = adapter() | |
| session = DOMINOEpisode(value, value.episodes(0)[0]) | |
| env = SimpleNamespace(close_env=Mock(side_effect=RuntimeError("close failed")), | |
| release_episode_resources=Mock()) | |
| session.env, session.cache = env, Path("/owned/cache") | |
| with patch("benchmarks.simBenchmarks.DOMINO.environment.runtime.native_directory", return_value=nullcontext()): | |
| with self.assertRaises(RuntimeError): | |
| session.close() | |
| with self.assertRaises(RuntimeError): | |
| session.close() | |
| env.close_env.assert_called_once() | |
| env.release_episode_resources.assert_called_once() | |
| def test_observation_failure_keeps_native_counts_but_no_ack(self): | |
| value = adapter() | |
| session = DOMINOEpisode(value, value.episodes(0)[0]) | |
| env = Env() | |
| env.take_action_cnt = 0 | |
| session.env, session.cache, session.reset_completed = env, Path("/owned/cache"), True | |
| session.counter = SceneStepCounter(SimpleNamespace(step=lambda: None)) | |
| session.outcome = NativeOutcome(env, {}, Tracker) | |
| def take_action(values, action_type): | |
| env.take_action_cnt += 1 | |
| session.counter.step() | |
| env._metrics_tracker.on_step() | |
| env.take_action = take_action | |
| with patch("benchmarks.simBenchmarks.DOMINO.environment.runtime.native_directory", return_value=nullcontext()), \ | |
| patch.object(session, "_observe", side_effect=RuntimeError("video failed")): | |
| with self.assertRaisesRegex(RuntimeError, "video failed"): | |
| session.step([0.] * 14) | |
| self.assertEqual((session.native_steps, session.step_count, session.acknowledged_controls, session.physics_ticks), (1, 1, 0, 1)) | |
| self.assertTrue(session.control_error) | |
| self.assertEqual(session.metrics()["metrics_tracker_steps"], 1) | |
| def test_native_swallowed_tracker_error_is_detected(self): | |
| value = adapter() | |
| session = DOMINOEpisode(value, value.episodes(0)[0]) | |
| env = Env() | |
| env.take_action_cnt = 0 | |
| session.env, session.cache, session.reset_completed = env, Path("/owned/cache"), True | |
| session.counter = SceneStepCounter(SimpleNamespace(step=lambda: None)) | |
| session.outcome = NativeOutcome(env, {}, Tracker) | |
| def missing_hook(values, action_type): | |
| env.take_action_cnt += 1 | |
| env.take_action = missing_hook | |
| with patch("benchmarks.simBenchmarks.DOMINO.environment.runtime.native_directory", return_value=nullcontext()): | |
| with self.assertRaisesRegex(RuntimeError, "tracker count"): | |
| session.step([0.] * 14) | |
| self.assertEqual((session.native_steps, session.acknowledged_controls), (1, 0)) | |
| self.assertEqual(session.metrics()["metrics_tracker_steps"], 0) | |
| def test_unknown_bytecode_is_not_ignored_by_inventory(self): | |
| with TemporaryDirectory() as directory: | |
| root = Path(directory) | |
| (root / "source.py").write_text("pass\n") | |
| rows = inventory(root) | |
| (root / "source.pyc").write_bytes(b"untracked executable bytes") | |
| with self.assertRaises(ValueError): | |
| verify_rows(root, rows) | |
| def test_symlinks_rejected(self): | |
| with TemporaryDirectory() as directory: | |
| root = Path(directory) | |
| (root / "source.py").write_text("pass\n") | |
| (root / "alias.py").symlink_to(root / "source.py") | |
| with self.assertRaises(ValueError): | |
| inventory(root) | |
| if __name__ == "__main__": | |
| unittest.main() | |