Datasets:

od2961
/

ModeBench

"""Networkless JSON-lines worker for 0.5B maze action programs."""

from __future__ import annotations

import json
import math
import os
import signal
import sys
from typing import Any, Mapping

from .maze_modebench import (
    ANT_MAZE_VERIFIER,
    POINT_MAZE_VERIFIER,
    parse_maze_action_program,
    parse_maze_action_spec,
    validate_maze_execution,
)
from .maze_runtime_identity import maze_runtime_identity
from .ant_maze_worker_v5 import execute_ant_v5
from .ant_maze_worker_v5 import RECEIPT_SHA256 as ANT_V5_RECEIPT_SHA256
from .ant_maze_worker_v8 import execute_ant_v8
from .ant_maze_worker_v8 import RECEIPT_SHA256 as ANT_V8_RECEIPT_SHA256
from .ant_maze_worker_v9 import controller_receipt_sha256 as ant_v9_receipt_sha256
from .ant_maze_worker_v9 import execute_ant_v9
from .ant_maze_worker_v10 import controller_receipt_sha256 as ant_v10_receipt_sha256
from .ant_maze_worker_v10 import execute_ant_v10
from .ant_maze_worker_v11 import controller_receipt_sha256 as ant_v11_receipt_sha256
from .ant_maze_worker_v11 import execute_ant_v11
from .ant_maze_worker_v12 import controller_receipt_sha256 as ant_v12_receipt_sha256
from .ant_maze_worker_v12 import execute_ant_v12


WORKER_TIMEOUT_SECONDS = float(
    os.environ.get("OAT_ZERO_MAZE_WORKER_TIMEOUT_SECONDS", "20.0")
)
if not math.isfinite(WORKER_TIMEOUT_SECONDS) or WORKER_TIMEOUT_SECONDS <= 0:
    raise ValueError("maze worker timeout must be finite and positive")


def _timeout(_signum, _frame) -> None:
    raise TimeoutError("maze action-program execution timed out")


def _point_action(token: str):
    import numpy as np

    diagonal = 1.0 / math.sqrt(2.0)
    values = {
        "N": (0.0, 1.0),
        "NE": (diagonal, diagonal),
        "E": (1.0, 0.0),
        "SE": (diagonal, -diagonal),
        "S": (0.0, -1.0),
        "SW": (-diagonal, -diagonal),
        "W": (-1.0, 0.0),
        "NW": (-diagonal, diagonal),
        "COAST": (0.0, 0.0),
    }
    return np.asarray(values[token], dtype=np.float32)


def _execute_point(candidate: str, raw_spec: Mapping[str, Any]):
    import gymnasium as gym
    import gymnasium_robotics
    import numpy as np

    gym.register_envs(gymnasium_robotics)
    spec = parse_maze_action_spec(raw_spec)
    if spec.verifier != POINT_MAZE_VERIFIER:
        raise ValueError("PointMaze executor received a non-PointMaze spec")
    runtime = maze_runtime_identity()
    if spec.environment_sha256 != runtime["point_environment_sha256"]:
        raise ValueError("PointMaze environment hash differs from installed runtime")
    tokens = parse_maze_action_program(candidate, spec)
    env = gym.make(
        spec.environment_id,
        maze_map=[list(row) for row in spec.maze_map],
        reward_type="sparse",
        continuing_task=False,
        reset_target=False,
        max_episode_steps=len(tokens) * spec.action_repeat,
    )
    try:
        # Gymnasium-Robotics 1.4.2 forwards this constructor argument to the
        # nested PointEnv, so bind it on the MazeEnv before reset instead.
        env.unwrapped.position_noise_range = 0.0
        observation, info = env.reset(
            seed=spec.reset_seed,
            options={
                "reset_cell": list(spec.reset_cell),
                "goal_cell": list(spec.goal_cell),
            },
        )
        trajectory = [observation["achieved_goal"].astype(float).tolist()]
        success = bool(info.get("success", False))
        simulator_steps = 0
        for token in tokens:
            action = _point_action(token)
            for _ in range(spec.action_repeat):
                observation, _reward, terminated, truncated, info = env.step(action)
                simulator_steps += 1
                achieved = observation["achieved_goal"].astype(float)
                trajectory.append(achieved.tolist())
                success = bool(info.get("success", False))
                if success or terminated or truncated:
                    break
            if success or terminated or truncated:
                break
        distance = float(
            np.linalg.norm(
                observation["achieved_goal"] - observation["desired_goal"]
            )
        )
    finally:
        env.close()
    execution = {
        "environment_sha256": spec.environment_sha256,
        "controller_sha256": None,
        "spec_sha256": spec.spec_sha256,
        "reset_seed": spec.reset_seed,
        "action_tokens": list(tokens),
        "success": success,
        "final_goal_distance": distance,
        "trajectory_xy": trajectory,
        "simulator_steps": simulator_steps,
    }
    return validate_maze_execution(candidate, raw_spec, execution), execution


def execute(candidate: str, raw_spec: Mapping[str, Any]):
    spec = parse_maze_action_spec(raw_spec)
    if spec.verifier == POINT_MAZE_VERIFIER:
        return _execute_point(candidate, raw_spec)
    if spec.verifier == ANT_MAZE_VERIFIER:
        if spec.controller_sha256 == ANT_V5_RECEIPT_SHA256:
            return execute_ant_v5(candidate, raw_spec)
        if spec.controller_sha256 == ANT_V8_RECEIPT_SHA256:
            return execute_ant_v8(candidate, raw_spec)
        # V12 route identities are intentionally incompatible with the older
        # controller-specific route schemas.  Resolve the newest bound
        # controller before asking any older validator to inspect that identity.
        if spec.controller_sha256 == ant_v12_receipt_sha256():
            return execute_ant_v12(candidate, raw_spec)
        if spec.controller_sha256 == ant_v9_receipt_sha256():
            return execute_ant_v9(candidate, raw_spec)
        if spec.controller_sha256 == ant_v10_receipt_sha256():
            return execute_ant_v10(candidate, raw_spec)
        if spec.controller_sha256 == ant_v11_receipt_sha256():
            return execute_ant_v11(candidate, raw_spec)
        raise ValueError("unsupported AntMaze controller identity")
    raise ValueError("unsupported maze verifier")


def main() -> None:
    signal.signal(signal.SIGALRM, _timeout)
    for line in sys.stdin:
        try:
            request = json.loads(line)
            signal.setitimer(signal.ITIMER_REAL, WORKER_TIMEOUT_SECONDS)
            validation, execution = execute(request["candidate"], request["spec"])
            payload = {
                "valid": True,
                "canonical_key": validation.canonical_key,
                "directed_gates": list(validation.directed_gates),
                "action_tokens": list(validation.action_tokens),
                "simulator_steps": validation.simulator_steps,
                "execution": execution,
            }
        except Exception as error:
            payload = {"valid": False, "error": type(error).__name__}
        finally:
            signal.setitimer(signal.ITIMER_REAL, 0.0)
        sys.stdout.write(json.dumps(payload, allow_nan=False) + "\n")
        sys.stdout.flush()


if __name__ == "__main__":
    main()

	"""Networkless JSON-lines worker for 0.5B maze action programs."""

	from __future__ import annotations

	import json
	import math
	import os
	import signal
	import sys
	from typing import Any, Mapping

	from .maze_modebench import (
	ANT_MAZE_VERIFIER,
	POINT_MAZE_VERIFIER,
	parse_maze_action_program,
	parse_maze_action_spec,
	validate_maze_execution,
	)
	from .maze_runtime_identity import maze_runtime_identity
	from .ant_maze_worker_v5 import execute_ant_v5
	from .ant_maze_worker_v5 import RECEIPT_SHA256 as ANT_V5_RECEIPT_SHA256
	from .ant_maze_worker_v8 import execute_ant_v8
	from .ant_maze_worker_v8 import RECEIPT_SHA256 as ANT_V8_RECEIPT_SHA256
	from .ant_maze_worker_v9 import controller_receipt_sha256 as ant_v9_receipt_sha256
	from .ant_maze_worker_v9 import execute_ant_v9
	from .ant_maze_worker_v10 import controller_receipt_sha256 as ant_v10_receipt_sha256
	from .ant_maze_worker_v10 import execute_ant_v10
	from .ant_maze_worker_v11 import controller_receipt_sha256 as ant_v11_receipt_sha256
	from .ant_maze_worker_v11 import execute_ant_v11
	from .ant_maze_worker_v12 import controller_receipt_sha256 as ant_v12_receipt_sha256
	from .ant_maze_worker_v12 import execute_ant_v12


	WORKER_TIMEOUT_SECONDS = float(
	os.environ.get("OAT_ZERO_MAZE_WORKER_TIMEOUT_SECONDS", "20.0")
	)
	if not math.isfinite(WORKER_TIMEOUT_SECONDS) or WORKER_TIMEOUT_SECONDS <= 0:
	raise ValueError("maze worker timeout must be finite and positive")


	def _timeout(_signum, _frame) -> None:
	raise TimeoutError("maze action-program execution timed out")


	def _point_action(token: str):
	import numpy as np

	diagonal = 1.0 / math.sqrt(2.0)
	values = {
	"N": (0.0, 1.0),
	"NE": (diagonal, diagonal),
	"E": (1.0, 0.0),
	"SE": (diagonal, -diagonal),
	"S": (0.0, -1.0),
	"SW": (-diagonal, -diagonal),
	"W": (-1.0, 0.0),
	"NW": (-diagonal, diagonal),
	"COAST": (0.0, 0.0),
	}
	return np.asarray(values[token], dtype=np.float32)


	def _execute_point(candidate: str, raw_spec: Mapping[str, Any]):
	import gymnasium as gym
	import gymnasium_robotics
	import numpy as np

	gym.register_envs(gymnasium_robotics)
	spec = parse_maze_action_spec(raw_spec)
	if spec.verifier != POINT_MAZE_VERIFIER:
	raise ValueError("PointMaze executor received a non-PointMaze spec")
	runtime = maze_runtime_identity()
	if spec.environment_sha256 != runtime["point_environment_sha256"]:
	raise ValueError("PointMaze environment hash differs from installed runtime")
	tokens = parse_maze_action_program(candidate, spec)
	env = gym.make(
	spec.environment_id,
	maze_map=[list(row) for row in spec.maze_map],
	reward_type="sparse",
	continuing_task=False,
	reset_target=False,
	max_episode_steps=len(tokens) * spec.action_repeat,
	)
	try:
	# Gymnasium-Robotics 1.4.2 forwards this constructor argument to the
	# nested PointEnv, so bind it on the MazeEnv before reset instead.
	env.unwrapped.position_noise_range = 0.0
	observation, info = env.reset(
	seed=spec.reset_seed,
	options={
	"reset_cell": list(spec.reset_cell),
	"goal_cell": list(spec.goal_cell),
	},
	)
	trajectory = [observation["achieved_goal"].astype(float).tolist()]
	success = bool(info.get("success", False))
	simulator_steps = 0
	for token in tokens:
	action = _point_action(token)
	for _ in range(spec.action_repeat):
	observation, _reward, terminated, truncated, info = env.step(action)
	simulator_steps += 1
	achieved = observation["achieved_goal"].astype(float)
	trajectory.append(achieved.tolist())
	success = bool(info.get("success", False))
	if success or terminated or truncated:
	break
	if success or terminated or truncated:
	break
	distance = float(
	np.linalg.norm(
	observation["achieved_goal"] - observation["desired_goal"]
	)
	)
	finally:
	env.close()
	execution = {
	"environment_sha256": spec.environment_sha256,
	"controller_sha256": None,
	"spec_sha256": spec.spec_sha256,
	"reset_seed": spec.reset_seed,
	"action_tokens": list(tokens),
	"success": success,
	"final_goal_distance": distance,
	"trajectory_xy": trajectory,
	"simulator_steps": simulator_steps,
	}
	return validate_maze_execution(candidate, raw_spec, execution), execution


	def execute(candidate: str, raw_spec: Mapping[str, Any]):
	spec = parse_maze_action_spec(raw_spec)
	if spec.verifier == POINT_MAZE_VERIFIER:
	return _execute_point(candidate, raw_spec)
	if spec.verifier == ANT_MAZE_VERIFIER:
	if spec.controller_sha256 == ANT_V5_RECEIPT_SHA256:
	return execute_ant_v5(candidate, raw_spec)
	if spec.controller_sha256 == ANT_V8_RECEIPT_SHA256:
	return execute_ant_v8(candidate, raw_spec)
	# V12 route identities are intentionally incompatible with the older
	# controller-specific route schemas. Resolve the newest bound
	# controller before asking any older validator to inspect that identity.
	if spec.controller_sha256 == ant_v12_receipt_sha256():
	return execute_ant_v12(candidate, raw_spec)
	if spec.controller_sha256 == ant_v9_receipt_sha256():
	return execute_ant_v9(candidate, raw_spec)
	if spec.controller_sha256 == ant_v10_receipt_sha256():
	return execute_ant_v10(candidate, raw_spec)
	if spec.controller_sha256 == ant_v11_receipt_sha256():
	return execute_ant_v11(candidate, raw_spec)
	raise ValueError("unsupported AntMaze controller identity")
	raise ValueError("unsupported maze verifier")


	def main() -> None:
	signal.signal(signal.SIGALRM, _timeout)
	for line in sys.stdin:
	try:
	request = json.loads(line)
	signal.setitimer(signal.ITIMER_REAL, WORKER_TIMEOUT_SECONDS)
	validation, execution = execute(request["candidate"], request["spec"])
	payload = {
	"valid": True,
	"canonical_key": validation.canonical_key,
	"directed_gates": list(validation.directed_gates),
	"action_tokens": list(validation.action_tokens),
	"simulator_steps": validation.simulator_steps,
	"execution": execution,
	}
	except Exception as error:
	payload = {"valid": False, "error": type(error).__name__}
	finally:
	signal.setitimer(signal.ITIMER_REAL, 0.0)
	sys.stdout.write(json.dumps(payload, allow_nan=False) + "\n")
	sys.stdout.flush()


	if __name__ == "__main__":
	main()