JackAILab's picture
Add files using upload-large-folder tool
6aa6c12 verified
Raw History Blame Contribute Delete
31 kB
"""Fake native objects only; optional helper check executes pure verified math."""
from __future__ import annotations
import ast
import base64
import contextlib
import hashlib
import io
import json
import math
import os
from pathlib import Path
import re
import shlex
import subprocess
import sys
import tempfile
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from benchkit.contracts import Observation
from benchkit.errors import CompatibilityError, ProtocolError
from benchmarks.simBenchmarks.calvin import server
from benchmarks.simBenchmarks.calvin.bench_server import adapter
from benchmarks.simBenchmarks.calvin.environment import runtime
DIRECTORY = Path(__file__).resolve().parents[1]
def example():
return json.loads((DIRECTORY / "server.example.json").read_text())
def fnv_unicode(value):
result = 0
for byte in value.encode("utf-16le"):
result = ((result * 16777619) & 0xffffffff) ^ byte
return result
class FakeNative:
def __init__(self, outcomes=()):
self.trace = SimpleNamespace(phase="construction",
completed_ticks={"construction": 0, "reset": 0, "control": 0},
started_ticks={"construction": 0, "reset": 0, "control": 0})
self.actions, self.baselines, self.oracle_calls = [], [], []
self.outcomes = iter(outcomes)
self.private = {"scene_obs": "never public", "rgb_obs": {}, "future_tasks": "never public"}
self.env = SimpleNamespace(reset=Mock(side_effect=self.reset), step=Mock(side_effect=self.step),
get_info=Mock(side_effect=self.get_info))
self.oracle = SimpleNamespace(get_task_info_for_set=Mock(side_effect=self.oracle_query))
self.construct = Mock()
self.close = Mock(return_value=({"constructed": True, "native_close_returned": True}, []))
def reset(self, **kwargs):
self.trace.started_ticks["reset"] += 1
self.trace.completed_ticks["reset"] += 1
return self.private
def get_info(self):
baseline = object()
self.baselines.append(baseline)
return baseline
def step(self, action):
self.actions.append(tuple(action))
self.trace.started_ticks["control"] += 8
self.trace.completed_ticks["control"] += 8
return self.private, 0, False, object()
def oracle_query(self, baseline, current, tasks):
self.oracle_calls.append((baseline, current, tasks))
return set(tasks) if next(self.outcomes, False) else set()
def session_fixture(outcomes=()):
benchmark = server.make_calvin(example())
episode, = benchmark.episodes(20260907, 1)
session = benchmark.open_episode(episode)
native = FakeNative(outcomes)
session.native, session.trace = native, native.trace
session.reset_attempted = session.native_reset_returned = session.reset_completed = True
session.native_outcome = "in_progress"
session.start_info = native.get_info()
session._observe = lambda raw: Observation(step=session.step_count,
instruction=benchmark.sequence["instructions"][session.subtask_index])
return session, native
class CalvinServerChecks(unittest.TestCase):
def test_factory_is_lazy_and_declares_debug_prefix_and_native_ceiling(self):
benchmark = server.make_calvin(example())
episode, = benchmark.episodes(20260907, 1)
self.assertEqual(benchmark.descriptor.name, "calvin")
self.assertEqual(benchmark.descriptor.source_revision, runtime.NATIVE_REVISION)
self.assertEqual(benchmark.budget_mode, "horizon")
self.assertEqual(benchmark.required_replan_interval, 1)
self.assertFalse(hasattr(benchmark, "max_policy_calls"))
self.assertEqual(episode.metadata["native_horizon"], 1800)
self.assertEqual(episode.metadata["native_subtask_horizon"], 360)
self.assertEqual(benchmark.observation_spec.cameras, adapter.CAMERAS)
self.assertEqual(benchmark.observation_spec.state_names, ())
self.assertEqual((benchmark.action_spec.size, benchmark.action_spec.control_hz), (7, 30))
self.assertEqual(episode.instruction, benchmark.sequence["instructions"][0])
self.assertNotIn("tasks", episode.metadata)
def test_factory_rejects_unreviewed_tracks_and_model_parameters(self):
for update in ({"track": "full"}, {"track": []}, {"evaluation_mode": "full"},
{"source_root": "relative"}, {"dataset_root": "/tmp/../data"},
{"source_root": True}, {"sequence_index": 1}, {"seed_search": True},
{"max_policy_calls": 1800}, {"subtask_horizon": 500}, {"action_mode": "absolute"}):
with self.subTest(update=update), self.assertRaises(ValueError):
server.make_calvin({**example(), **update})
with self.assertRaises(ValueError):
server.make_calvin({})
benchmark = server.make_calvin(example())
for seed, limit in ((True, 1), (-1, 1), (1, 2), (1, True), (1, 0)):
with self.assertRaises(ValueError):
benchmark.episodes(seed, limit)
def test_action_validation_rejects_bad_values_without_clipping(self):
spec = server.make_calvin(example()).action_spec
self.assertEqual(spec.validate([0] * 6 + [1]), (0.0,) * 6 + (1.0,))
for value in (True, float("nan"), float("inf"), -1.01, 1.01):
with self.assertRaises((TypeError, ValueError)):
spec.validate([value] + [0] * 6)
def test_attempt_consumed_before_reset_and_never_retried(self):
benchmark = server.make_calvin(example())
episode, = benchmark.episodes(0)
session = benchmark.open_episode(episode)
with self.assertRaises(ProtocolError):
benchmark.open_episode(episode)
with self.assertRaises(ProtocolError):
session.reset() # No artifact root: fails before native imports.
self.assertTrue(session.metrics()["reset_attempted"])
self.assertFalse(session.metrics()["native_reset_returned"])
with self.assertRaises(ProtocolError):
session.reset()
def test_artifact_binding_rejects_terminal_sessions(self):
with tempfile.TemporaryDirectory() as temporary:
for method in ("close", "artifacts"):
benchmark = server.make_calvin(example())
session = benchmark.open_episode(benchmark.episodes(0)[0])
getattr(session, method)()
target = Path(temporary) / method
with self.assertRaises(ProtocolError):
session.bind_artifact_dir(target)
self.assertFalse(target.exists())
def test_factory_does_not_import_native_numpy_or_models(self):
script = """
import json,sys
from benchmarks.simBenchmarks.calvin.server import make_calvin
with open('benchmarks/simBenchmarks/calvin/server.example.json') as stream:
benchmark=make_calvin(json.load(stream))
assert len(benchmark.episodes(0))==1
for name in ('numpy','torch','pybullet','calvin_env','calvin_agent','AgentPolicies'):
assert not any(key==name or key.startswith(name+'.') for key in sys.modules), name
"""
result = subprocess.run([sys.executable, "-B", "-S", "-c", script], cwd=DIRECTORY.parents[2],
capture_output=True, text=True, timeout=30)
self.assertEqual(result.returncode, 0, result.stderr)
def test_literal_readme_command_parses(self):
from benchkit.cli import build_parser
blocks = re.findall(r"```sh\n(.*?)\n```", (DIRECTORY / "README.md").read_text(), re.DOTALL)
command, = [block for block in blocks if block.startswith("python -B -m benchkit run")]
tokens = shlex.split(command.replace("\\\n", " "))
args = build_parser().parse_args(tokens[4:])
self.assertEqual((args.benchmark, args.sim_server), ("calvin", "http://127.0.0.1:8772"))
self.assertEqual((args.max_policy_calls, args.replan_interval, args.max_steps), (200, 1, 1800))
self.assertEqual(args.model_profile, "anonymous_code_agent")
self.assertEqual(args.policy_args, {"directory": "/absolute/opaque-mailbox"})
self.assertEqual(args.budget_mode, "horizon")
def test_entrypoint_and_describe_do_not_construct_native(self):
with patch.object(server, "launch", return_value=0) as launch:
self.assertEqual(server.main(["--help"]), 0)
launch.assert_called_once_with(server.make_calvin, supplemental_sources=server.SUPPLEMENTAL_FILES,
argv=["--help"])
with tempfile.TemporaryDirectory() as temporary:
http = Mock(server_port=8772)
descriptions = []
def connect(service, **kwargs):
self.assertFalse(service.sessions)
descriptions.append(service.dispatch("describe", {}))
return http
with contextlib.ExitStack() as stack:
stack.enter_context(patch.dict(os.environ, {"RSI_SIM_SERVER_TOKEN": "x" * 48}))
stack.enter_context(patch("benchkit.sim_server.launch.make_http_server", side_effect=connect))
stack.enter_context(patch("benchkit.source_snapshot.capture_harness_source", return_value={"scope": "CPU launcher fixture"}))
stack.enter_context(patch.object(adapter.CalvinBenchmarkAdapter, "open_episode", side_effect=AssertionError("native")))
stdout = stack.enter_context(contextlib.redirect_stdout(io.StringIO()))
result = server.main(["--parameters", str(DIRECTORY / "server.example.json"), "--seed", "0",
"--episodes", "1", "--port", "8772", "--output-dir", str(Path(temporary) / "service")])
self.assertEqual(result, 0)
self.assertEqual(json.loads(stdout.getvalue())["native_resets"], 0)
self.assertEqual(descriptions[0]["budget"]["required_replan_interval"], 1)
http.server_close.assert_called_once()
class SequenceBoundaryChecks(unittest.TestCase):
def test_success_transitions_language_once_without_reset_or_future_data(self):
session, native = session_fixture([True, False])
baseline = session.start_info
with patch.object(adapter, "native_action", side_effect=tuple):
first = session.step((0.0,) * 7)
second = session.step((0.0,) * 7)
self.assertEqual(first.observation.instruction, session.benchmark.sequence["instructions"][1])
self.assertEqual(second.observation.instruction, first.observation.instruction)
self.assertIsNone(first.observation.state)
self.assertEqual(first.observation.metadata, {})
self.assertFalse(first.terminated or first.truncated)
self.assertEqual(native.oracle_calls[0][0], baseline)
self.assertEqual(native.oracle_calls[0][2], {session.benchmark.sequence["tasks"][0]})
self.assertEqual(native.oracle_calls[1][2], {session.benchmark.sequence["tasks"][1]})
self.assertIsNot(native.oracle_calls[1][0], baseline)
native.env.reset.assert_not_called()
self.assertEqual((session.depth, session.subtask_controls, session.step_count), (1, 1, 2))
def test_oracle_success_at_control_360_precedes_timeout(self):
session, native = session_fixture([False] * 359 + [True])
with patch.object(adapter, "native_action", side_effect=tuple):
for _ in range(360):
transition = session.step((0.0,) * 7)
self.assertFalse(transition.terminated or transition.truncated)
self.assertEqual((session.depth, session.subtask_controls), (1, 0))
self.assertEqual(session.metrics()["completed_subtasks"][0]["controls"], 360)
self.assertEqual(len(native.actions), 360)
def test_first_failed_subtask_stops_chain_exactly_at_360(self):
session, native = session_fixture()
with patch.object(adapter, "native_action", side_effect=tuple):
for _ in range(360):
transition = session.step((0.0,) * 7)
with self.assertRaises(ProtocolError):
session.step((0.0,) * 7)
self.assertTrue(transition.truncated)
self.assertFalse(transition.terminated)
self.assertEqual(session.metrics()["native_outcome"], "subtask_horizon_failure")
self.assertEqual((session.depth, len(native.oracle_calls), len(native.actions)), (0, 360, 360))
def test_five_successes_complete_sequence_and_record_actual_steps(self):
session, native = session_fixture([True] * 5)
with patch.object(adapter, "native_action", side_effect=tuple):
for _ in range(5):
transition = session.step((0.0,) * 7)
self.assertTrue(transition.terminated)
self.assertFalse(transition.truncated)
self.assertEqual(session.depth, 5)
self.assertEqual([row["completion_control"] for row in session.completed_subtasks], [1, 2, 3, 4, 5])
self.assertEqual(session.metrics()["policy_physics_ticks"], 40)
native.env.reset.assert_not_called()
def test_error_after_native_step_is_not_replayed_and_keeps_counts(self):
session, native = session_fixture()
failure = RuntimeError("private oracle error")
native.oracle.get_task_info_for_set.side_effect = failure
with patch.object(adapter, "native_action", side_effect=tuple):
with self.assertRaises(RuntimeError) as caught:
session.step((0.0,) * 7)
with self.assertRaises(ProtocolError):
session.step((0.0,) * 7)
self.assertIs(caught.exception, failure)
self.assertEqual((session.started_controls, session.step_count, session.acknowledged_controls), (1, 1, 0))
self.assertEqual(session.metrics()["policy_physics_ticks"], 8)
native.env.step.assert_called_once()
def test_unexpected_oracle_task_is_an_error_not_success(self):
session, native = session_fixture()
native.oracle.get_task_info_for_set.side_effect = lambda *args: {"future_task"}
with patch.object(adapter, "native_action", side_effect=tuple), self.assertRaises(ProtocolError):
session.step((0.0,) * 7)
self.assertFalse(session.success)
self.assertEqual(session.depth, 0)
def test_external_early_stop_preserves_depth_without_timeout_claim(self):
session, native = session_fixture([True])
with patch.object(adapter, "native_action", side_effect=tuple):
session.step((0.0,) * 7)
session.close()
session.close()
self.assertEqual(session.metrics()["native_outcome"], "externally_stopped_incomplete")
self.assertEqual(session.depth, 1)
native.close.assert_called_once()
def test_close_failure_is_sticky_and_does_not_repeat_native_close(self):
session, native = session_fixture()
native.close.return_value = ({"native_close_returned": False}, [RuntimeError("cleanup")])
for _ in range(2):
with self.assertRaises(ProtocolError):
session.close()
native.close.assert_called_once()
def test_partial_reset_failure_keeps_tick_and_attempt(self):
benchmark = server.make_calvin(example())
session = benchmark.open_episode(benchmark.episodes(0)[0])
native = FakeNative()
failure = RuntimeError("reset render error")
def reset(**kwargs):
native.trace.completed_ticks["reset"] += 1
raise failure
native.env.reset.side_effect = reset
fake_numpy = SimpleNamespace(array=lambda value, **kwargs: list(value), float64=float)
with tempfile.TemporaryDirectory() as temporary, contextlib.ExitStack() as stack:
session.bind_artifact_dir(Path(temporary))
stack.enter_context(patch.object(runtime, "readiness", return_value={}))
stack.enter_context(patch.object(runtime, "prepare_native", return_value=native))
stack.enter_context(patch.dict(sys.modules, {"numpy": fake_numpy}))
with self.assertRaises(RuntimeError) as caught:
session.reset()
self.assertIs(caught.exception, failure)
metrics = session.metrics()
self.assertEqual(metrics["initialization_physics_ticks"], 1)
self.assertFalse(metrics["native_reset_returned"] or metrics["reset_completed"])
with self.assertRaises(ProtocolError):
session.reset()
self.assertTrue((Path(temporary) / "native_provenance.json").is_file())
native.env.reset.assert_called_once()
native.close.assert_called_once()
def test_faulted_service_finish_transfers_partial_reset_counters(self):
from benchkit.sim_server.server import BenchmarkService, ServiceError
benchmark = server.make_calvin(example())
native = FakeNative()
def reset(**kwargs):
native.trace.started_ticks["reset"] += 1
native.trace.completed_ticks["reset"] += 1
raise RuntimeError("reset rendering failed after its physical tick")
native.env.reset.side_effect = reset
fake_numpy = SimpleNamespace(array=lambda value, **kwargs: list(value), float64=float)
with tempfile.TemporaryDirectory() as temporary, contextlib.ExitStack() as stack:
stack.enter_context(patch.object(runtime, "readiness", return_value={}))
stack.enter_context(patch.object(runtime, "prepare_native", return_value=native))
stack.enter_context(patch.dict(sys.modules, {"numpy": fake_numpy}))
service = BenchmarkService(benchmark, root=Path(temporary) / "service", seed=0, limit=1)
sid = service.dispatch("open", {"episode_id": service.episodes[0].id})["session_id"]
with self.assertRaises(ServiceError):
service.dispatch("reset", {"session_id": sid, "sequence": 0})
with self.assertRaises(ServiceError):
service.dispatch("metrics", {"session_id": sid})
final = service.dispatch("finish", {"session_id": sid})
self.assertIsNone(final["cleanup_error"], (service.sessions[sid]["root"] / "sim_server_errors.jsonl").read_text())
self.assertIn("native_metrics.json", [row["path"] for row in final["files"]])
path = final["artifacts"]["native_metrics"]
response = service.dispatch("read_artifact", {"session_id": sid, "path": path, "offset": 0})
metrics = json.loads(base64.b64decode(response["data"]))
self.assertEqual(metrics["completed_physics_ticks_by_phase"]["reset"], 1)
self.assertEqual(metrics["started_physics_ticks_by_phase"]["reset"], 1)
self.assertEqual((metrics["started_controls"], metrics["native_steps"], metrics["acknowledged_controls"]), (0, 0, 0))
self.assertEqual(metrics["native_outcome"], "reset_error")
native.env.reset.assert_called_once()
native.close.assert_called_once()
class RuntimeBoundaryChecks(unittest.TestCase):
def _native_runtime_fixture(self):
clients = set()
def connect(*args, **kwargs):
clients.add(0)
return 0
bullet = SimpleNamespace(connect=Mock(side_effect=connect), stepSimulation=Mock(),
isConnected=Mock(side_effect=lambda **kwargs: kwargs["physicsClientId"] in clients),
disconnect=Mock(side_effect=lambda **kwargs: clients.remove(kwargs["physicsClientId"])))
class BareEnv:
def __init__(self, **kwargs):
raise AssertionError("native constructor must not be invoked in CPU cleanup tests")
def close(self):
if self.ownsPhysicsClient and self.cid >= 0:
self.p.disconnect(physicsClientId=self.cid)
native = runtime.NativeRuntime(SimpleNamespace(PlayTableSimEnv=BareEnv, p=bullet), None, None)
return native, bullet, clients
def test_partial_egl_constructor_orphan_is_disconnected_once(self):
native, bullet, clients = self._native_runtime_fixture()
original_connect, original_step = bullet.connect, bullet.stepSimulation
native.trace.install()
self.assertEqual(bullet.connect("DIRECT"), 0)
native.env.ownsPhysicsClient = True
self.assertEqual(native.env.cid, -1) # Native assigns cid after EGL loading.
receipt, errors = native.close()
self.assertFalse(errors)
self.assertEqual(receipt["orphan_disconnects"], [0])
self.assertEqual(receipt["disconnected"], [0])
bullet.disconnect.assert_called_once_with(physicsClientId=0)
self.assertFalse(clients)
self.assertFalse(native.env.ownsPhysicsClient)
self.assertIs(bullet.connect, original_connect)
self.assertIs(bullet.stepSimulation, original_step)
def test_normal_native_close_is_not_repeated_as_orphan_cleanup(self):
native, bullet, clients = self._native_runtime_fixture()
native.trace.install()
native.env.cid = bullet.connect("DIRECT")
native.env.ownsPhysicsClient = True
receipt, errors = native.close()
self.assertFalse(errors)
self.assertEqual(receipt["orphan_disconnects"], [])
bullet.disconnect.assert_called_once_with(physicsClientId=0)
self.assertFalse(clients)
def test_failed_native_disconnect_is_recorded_without_retry(self):
native, bullet, clients = self._native_runtime_fixture()
native.trace.install()
native.env.cid = bullet.connect("DIRECT")
native.env.ownsPhysicsClient = True
error = RuntimeError("disconnect failed")
bullet.disconnect.side_effect = error
receipt, errors = native.close()
self.assertIs(errors[0], error)
self.assertEqual(receipt["orphan_disconnects"], [])
self.assertEqual(receipt["disconnected"], [])
bullet.disconnect.assert_called_once_with(physicsClientId=0)
self.assertEqual(clients, {0})
self.assertFalse(native.env.ownsPhysicsClient)
def test_preexisting_client_rejected_before_native_constructor(self):
native, bullet, clients = self._native_runtime_fixture()
clients.add(0)
with self.assertRaises(CompatibilityError):
native.construct()
bullet.connect.assert_not_called()
bullet.stepSimulation.assert_not_called()
self.assertFalse(native.trace.installed)
native.close()
bullet.disconnect.assert_not_called()
self.assertEqual(clients, {0})
def test_nested_trace_rejected_and_wrong_client_id_owned_for_cleanup(self):
bullet = SimpleNamespace(connect=Mock(return_value=1), stepSimulation=Mock())
first = runtime.PhysicsTrace(bullet)
first.install()
second = runtime.PhysicsTrace(bullet)
with self.assertRaises(ProtocolError):
second.install()
with self.assertRaises(CompatibilityError):
bullet.connect("DIRECT")
self.assertEqual(first.clients, [1])
first.original_connect.assert_called_once_with("DIRECT")
first.original_step.assert_not_called()
first.restore()
self.assertFalse(hasattr(bullet, "_rsi_calvin_trace_owner"))
def test_passive_tick_and_connect_trace_returns_exact_objects(self):
token = object()
bullet = SimpleNamespace(connect=Mock(return_value=0), stepSimulation=Mock(return_value=token))
original_connect, original_step = bullet.connect, bullet.stepSimulation
trace = runtime.PhysicsTrace(bullet)
trace.install()
self.assertEqual(bullet.connect("DIRECT", options="x"), 0)
self.assertIs(bullet.stepSimulation(physicsClientId=0), token)
self.assertEqual(trace.completed_ticks, {"construction": 1, "reset": 0, "control": 0})
original_connect.assert_called_once_with("DIRECT", options="x")
original_step.assert_called_once_with(physicsClientId=0)
failure = RuntimeError("physics")
original_step.side_effect = failure
with self.assertRaises(RuntimeError) as caught:
bullet.stepSimulation(physicsClientId=0)
self.assertIs(caught.exception, failure)
self.assertEqual(trace.completed_ticks["construction"], 1)
self.assertEqual(trace.started_ticks["construction"], 2)
trace.restore()
self.assertIs(bullet.connect, original_connect)
self.assertIs(bullet.stepSimulation, original_step)
def test_frozen_input_drift_rejected(self):
self.assertEqual(len(runtime.frozen_sequence()["tasks"]), 5)
with patch.object(Path, "read_bytes", return_value=b"{}"), self.assertRaises(CompatibilityError):
runtime.frozen_sequence()
def test_actual_git_blob_bytes_checked_even_if_status_says_clean(self):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
(root / "source.py").write_bytes(b"different bytes")
expected = b"expected bytes"
blob = hashlib.sha1(b"blob " + str(len(expected)).encode() + b"\0" + expected).hexdigest()
output = [str(root).encode(), b"a" * 40, b"", f"100644 blob {blob}\tsource.py\0".encode()]
with patch.object(runtime, "_git", side_effect=output), self.assertRaises(CompatibilityError):
runtime.verify_tree(root, "a" * 40, 1)
def test_namespace_package_origins_must_be_exact(self):
root = Path("/absolute/native/calvin_env/calvin_env")
with patch.dict(sys.modules, {"calvin_env.envs": SimpleNamespace(__path__=[str(root / "envs")])}):
runtime.verify_loaded_native_modules(root)
for paths in (["/another/envs"], [str(root / "envs"), "/another/envs"], []):
with patch.dict(sys.modules, {"calvin_env.envs": SimpleNamespace(__path__=paths)}), self.assertRaises(CompatibilityError):
runtime.verify_loaded_native_modules(root)
def test_ignored_symlink_package_rejected_before_import(self):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
package = root / "calvin_env/calvin_env"
package.mkdir(parents=True)
external = root / "unfrozen"
external.mkdir()
(package / "envs").symlink_to(external, target_is_directory=True)
with patch.object(runtime, "_git", return_value=b""), patch.object(runtime.importlib, "import_module") as imported:
with self.assertRaises(CompatibilityError):
runtime._native_imports(root)
imported.assert_not_called()
def test_unicode_hash_derivation_and_retained_sequence_identity(self):
record = runtime.frozen_sequence()
self.assertEqual(fnv_unicode("hello world"), 3799943344)
representation = str(record["initial_condition"].values())
self.assertEqual(representation, record["derivation"]["initial_condition_repr"])
self.assertEqual(fnv_unicode(representation), record["derivation"]["fnv_seed"])
self.assertEqual(record["sequence_file"], "environment/eval_sequences.json")
data = (DIRECTORY / "bench_server/protocol/eval_sequences.json").read_bytes()
self.assertEqual(hashlib.sha256(data).hexdigest(), record["sequence_file_sha256"])
rows = json.loads(data)
self.assertEqual(len(rows), 1000)
self.assertEqual(rows[0], [record["initial_condition"], record["tasks"]])
@unittest.skipUnless(os.environ.get("CALVIN_NATIVE_SOURCE_ROOT"), "optional pinned native-source pure-math parity")
def test_frozen_initial_state_matches_extracted_native_helper(self):
import numpy as np
self.assertEqual(np.__version__, "1.26.4")
record = runtime.frozen_sequence()
path = Path(os.environ["CALVIN_NATIVE_SOURCE_ROOT"]) / "calvin_models/calvin_agent/evaluation/utils.py"
data = path.read_bytes()
self.assertEqual(hashlib.sha256(data).hexdigest(), record["derivation"]["helper_file_sha256"])
tree = ast.parse(data)
functions = [node for node in tree.body if isinstance(node, ast.FunctionDef)
and node.name in ("temp_seed", "get_env_state_for_initial_condition")]
self.assertEqual(len(functions), 2)
namespace = {"np": np, "pi": math.pi, "contextlib": contextlib, "hasher": fnv_unicode}
before = np.random.get_state()
exec(compile(ast.Module(body=functions, type_ignores=[]), str(path), "exec"), namespace)
robot, scene = namespace["get_env_state_for_initial_condition"](record["initial_condition"])
np.testing.assert_array_equal(robot, record["robot_obs"])
np.testing.assert_array_equal(scene, record["scene_obs"])
after = np.random.get_state()
self.assertEqual(before[0], after[0])
np.testing.assert_array_equal(before[1], after[1])
self.assertEqual(before[2:], after[2:])
self.assertNotIn("calvin_agent", sys.modules)
self.assertNotIn("torch", sys.modules)
try:
import numpy as np
except ImportError:
np = None
@unittest.skipIf(np is None, "NumPy optional for CPU array boundary checks")
class ArrayChecks(unittest.TestCase):
def test_public_rgb_is_exact_nonaliasing_and_drops_private_fields(self):
raw = {"rgb_obs": {name: np.arange(math.prod(shape), dtype=np.uint8).reshape(shape)
for name, shape in adapter.SHAPES.items()},
"robot_obs": np.ones(15), "scene_obs": np.ones(24), "depth_obs": {}, "oracle": "private"}
public = adapter.policy_observation(raw, 0, "current language")
self.assertEqual(tuple(public.images), adapter.CAMERAS)
self.assertEqual((public.state, public.metadata), (None, {}))
for name in adapter.CAMERAS:
np.testing.assert_array_equal(public.images[name], raw["rgb_obs"][name])
self.assertFalse(np.shares_memory(public.images[name], raw["rgb_obs"][name]))
raw["rgb_obs"]["rgb_static"] = np.zeros((84, 84, 3), dtype=np.uint8)
with self.assertRaises(ProtocolError):
adapter.policy_observation(raw, 0, "current language")
def test_native_action_is_writable_copy_and_exact_gripper_sign(self):
for gripper, expected in ((1, 1), (0, -1), (-1, -1)):
original = np.array([0.5] * 6 + [gripper], dtype=np.float64)
original.flags.writeable = False
native = adapter.native_action(original)
self.assertEqual(native[-1], expected)
self.assertTrue(native.flags.writeable)
self.assertFalse(np.shares_memory(native, original))
native[:3] *= 0.02
np.testing.assert_array_equal(original[:6], [0.5] * 6)
if __name__ == "__main__":
unittest.main()