synth-ai 0.1.9__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/environments/examples/red/units/test_button_press_requirements.py

@@ -0,0 +1,217 @@
+import pytest
+import asyncio
+import uuid
+
+from synth_ai.environments.examples.red.environment import (
+    PokemonRedEnvironment,
+    PokemonRedPublicState,
+    PokemonRedPrivateState,
+)
+from synth_ai.environments.environment.shared_engine import (
+    GetObservationCallable,
+    InternalObservation,
+)
+from synth_ai.environments.examples.red.taskset import PokemonRedTaskInstance
+from synth_ai.environments.tasks.core import Impetus, Intent, TaskInstanceMetadata
+from synth_ai.environments.environment.tools import EnvToolCall
+
+
+class PressButtonCall(EnvToolCall):
+    """Helper class for creating button press calls"""
+
+    def __init__(self, button: str, frames: int = 1):
+        super().__init__(tool="press_button", args={"button": button, "frames": frames})
+
+
+class ButtonTestObservationCallable(GetObservationCallable):
+    """Observation callable for systematic button testing"""
+
+    def __init__(self):
+        self.screen_buffer = None
+
+    async def get_observation(
+        self, pub: PokemonRedPublicState, priv: PokemonRedPrivateState
+    ) -> InternalObservation:
+        if pub is None or priv is None:
+            raise RuntimeError("Missing public or private state in get_observation")
+
+        # Extract screen buffer
+        try:
+            import inspect
+
+            frame = inspect.currentframe()
+            env = None
+
+            while frame:
+                if "self" in frame.f_locals and hasattr(frame.f_locals["self"], "engine"):
+                    env = frame.f_locals["self"]
+                    break
+                frame = frame.f_back
+
+            if env and hasattr(env, "engine") and env.engine:
+                if hasattr(env.engine, "emulator") and env.engine.emulator:
+                    if hasattr(env.engine.emulator, "screen"):
+                        screen_buffer = env.engine.emulator.screen.ndarray.copy()
+                        self.screen_buffer = screen_buffer
+        except Exception as e:
+            print(f"[DEBUG] Failed to extract screen buffer: {e}")
+
+        formatted_obs = (
+            f"Step: {pub.step_count}, Position: ({pub.player_x}, {pub.player_y}), Map: {pub.map_id}"
+        )
+
+        return {
+            "public": pub,
+            "private": priv,
+            "formatted_obs": formatted_obs,
+            "screen_buffer": self.screen_buffer,
+        }
+
+
+async def test_single_vs_multiple_presses():
+    """
+    Test how many button presses are needed for reliable movement in different directions.
+    """
+    print("\n" + "=" * 80)
+    print("SYSTEMATIC BUTTON PRESS REQUIREMENT ANALYSIS")
+    print("=" * 80)
+
+    # Test different buttons and press counts
+    test_scenarios = [
+        ("LEFT", "movement"),
+        ("RIGHT", "movement"),
+        ("UP", "movement"),
+        ("DOWN", "movement"),
+        ("A", "interaction"),
+        ("B", "cancel/back"),
+    ]
+
+    results = {}
+
+    for button, action_type in test_scenarios:
+        print(f"\n{'=' * 60}")
+        print(f"TESTING {button} BUTTON ({action_type})")
+        print(f"{'=' * 60}")
+
+        # Test with different numbers of presses (1-5)
+        button_results = {}
+
+        for press_count in range(1, 6):
+            print(f"\nTesting {press_count} press(es) of {button}...")
+
+            # Create fresh environment for each test
+            task_metadata = TaskInstanceMetadata()
+            inst = PokemonRedTaskInstance(
+                id=uuid.uuid4(),
+                impetus=Impetus(instructions=f"Test {button} button with {press_count} presses."),
+                intent=Intent(
+                    rubric={"goal": f"Test {button}"},
+                    gold_trajectories=None,
+                    gold_state_diff={},
+                ),
+                metadata=task_metadata,
+                is_reproducible=True,
+                initial_engine_snapshot=None,
+            )
+
+            test_obs = ButtonTestObservationCallable()
+            env = PokemonRedEnvironment(inst, custom_step_obs=test_obs)
+
+            try:
+                # Initialize
+                obs_payload = await env.initialize()
+                if "error" in obs_payload:
+                    print(f"[ERROR] Init failed: {obs_payload['error']}")
+                    continue
+
+                initial_pub = obs_payload["public"]
+                initial_position = (initial_pub.player_x, initial_pub.player_y)
+                initial_map_id = initial_pub.map_id
+
+                print(f"  Initial state: pos={initial_position}, map={initial_map_id}")
+
+                # Press button the specified number of times
+                final_position = initial_position
+                final_map_id = initial_map_id
+
+                for press_num in range(press_count):
+                    step_result = await env.step([[PressButtonCall(button)]])
+                    if "error" in step_result:
+                        print(f"  [ERROR] Step {press_num + 1} failed: {step_result['error']}")
+                        break
+
+                    new_pub = step_result["public"]
+                    final_position = (new_pub.player_x, new_pub.player_y)
+                    final_map_id = new_pub.map_id
+
+                # Analyze results
+                position_changed = final_position != initial_position
+                map_changed = final_map_id != initial_map_id
+
+                result = {
+                    "initial_position": initial_position,
+                    "final_position": final_position,
+                    "initial_map": initial_map_id,
+                    "final_map": final_map_id,
+                    "position_changed": position_changed,
+                    "map_changed": map_changed,
+                    "effective": position_changed or map_changed,
+                }
+
+                button_results[press_count] = result
+
+                print(f"  Result: pos={final_position}, map={final_map_id}")
+                print(f"  Effect: {'YES' if result['effective'] else 'NO'}")
+
+            except Exception as e:
+                print(f"  [ERROR] Test failed: {e}")
+                button_results[press_count] = {"error": str(e)}
+
+        results[button] = button_results
+
+    # Analysis and recommendations
+    print("\n" + "=" * 80)
+    print("ANALYSIS AND RECOMMENDATIONS")
+    print("=" * 80)
+
+    for button, button_results in results.items():
+        print(f"\n{button} BUTTON:")
+
+        # Find minimum presses for reliable effect
+        min_effective_presses = None
+        for press_count in range(1, 6):
+            if press_count in button_results:
+                result = button_results[press_count]
+                if not isinstance(result, dict) or "error" in result:
+                    continue
+                if result.get("effective", False):
+                    min_effective_presses = press_count
+                    break
+
+        if min_effective_presses:
+            print(f"  ✓ Minimum effective presses: {min_effective_presses}")
+            print(f"  ✓ Recommendation: Use {min_effective_presses} presses for {button}")
+        else:
+            print("  ✗ No effective movement detected with up to 5 presses")
+
+        # Show detailed results
+        for press_count, result in button_results.items():
+            if isinstance(result, dict) and "error" not in result:
+                effect_str = "EFFECTIVE" if result.get("effective") else "no effect"
+                print(f"    {press_count} press(es): {effect_str}")
+
+    return results
+
+
+@pytest.mark.asyncio
+async def test_button_press_requirements():
+    """Main test function"""
+    results = await test_single_vs_multiple_presses()
+
+    # The test always passes but provides diagnostic information
+    assert True, "Button press requirements test completed - see output for recommendations"
+
+
+if __name__ == "__main__":
+    # Run the test directly
+    asyncio.run(test_button_press_requirements())

synth_ai/environments/examples/red/units/test_engine.py

@@ -0,0 +1,192 @@
+import pytest
+from synth_ai.environments.examples.red.engine import (
+    PokemonRedEngine,
+    BUTTON_MAP,
+    PokemonRedEngineSnapshot,
+)
+from synth_ai.environments.examples.red.taskset import (
+    INSTANCE as DEFAULT_TASK,
+)
+
+
+class TestPokemonRedEngine:
+    """Test Pokemon Red engine functionality with REAL ROM"""
+
+    @pytest.fixture
+    def task_instance(self):
+        """Create a task instance"""
+        return DEFAULT_TASK
+
+    def test_button_map_completeness(self):
+        """Test that all expected buttons are mapped"""
+        expected_buttons = ["A", "B", "UP", "DOWN", "LEFT", "RIGHT", "START", "SELECT"]
+        assert all(button in BUTTON_MAP for button in expected_buttons)
+
+        # Each button should map to a string (PyBoy event name)
+        for button, mapped in BUTTON_MAP.items():
+            assert isinstance(mapped, str)
+            assert mapped
+
+    def test_engine_initialization(self, task_instance):
+        """Test engine initialization with REAL ROM"""
+        engine = PokemonRedEngine(task_instance)
+
+        assert engine.task_instance == task_instance
+        assert engine._total_reward == 0.0
+        assert engine._step_count == 0
+        assert engine._previous_state is None
+        assert engine.emulator is not None  # Should have real PyBoy instance
+
+    def test_rom_path_resolution(self, task_instance):
+        """Test ROM path resolution logic"""
+        engine = PokemonRedEngine(task_instance)
+        rom_path = engine._get_rom_path()
+
+        # Should find the actual ROM file
+        assert rom_path.exists()
+        assert rom_path.name == "pokemon_red.gb"
+
+    @pytest.mark.asyncio
+    async def test_press_button_real(self, task_instance):
+        """Test button press functionality with real ROM"""
+        engine = PokemonRedEngine(task_instance)
+
+        # Test valid button press - should not raise exception
+        engine._press_button("A", 1)
+
+        # Test multiple frames
+        engine._press_button("RIGHT", 3)
+
+    @pytest.mark.asyncio
+    async def test_press_button_invalid(self, task_instance):
+        """Test invalid button press"""
+        engine = PokemonRedEngine(task_instance)
+
+        with pytest.raises(ValueError, match="Invalid button: INVALID"):
+            engine._press_button("INVALID")
+
+    @pytest.mark.asyncio
+    async def test_extract_current_state_real(self, task_instance):
+        """Test state extraction from real emulator"""
+        engine = PokemonRedEngine(task_instance)
+        state = engine._extract_current_state()
+
+        # Should return a dictionary with expected keys (from actual state extraction)
+        expected_keys = [
+            "map_id",
+            "player_x",
+            "player_y",
+            "badges",
+            "party_hp_current",
+            "party_hp_max",
+            "party_level",
+            "party_xp",
+            "in_battle",
+            "battle_outcome",
+            "inventory_count",
+            "menu_state",
+            "warp_flag",
+        ]
+        for key in expected_keys:
+            assert key in state
+
+        # Values should be correct types
+        assert isinstance(state["map_id"], int)
+        assert isinstance(state["player_x"], int)
+        assert isinstance(state["player_y"], int)
+        assert isinstance(state["badges"], int)
+        assert isinstance(state["in_battle"], bool)
+
+    @pytest.mark.asyncio
+    async def test_reset_engine_real(self, task_instance):
+        """Test engine reset with real ROM"""
+        engine = PokemonRedEngine(task_instance)
+
+        priv, pub = await engine._reset_engine()
+
+        assert engine._total_reward == 0.0
+        assert engine._step_count == 0
+        assert priv.reward_last_step == 0.0
+        assert priv.total_reward == 0.0
+        assert not priv.terminated
+
+        # Public state should have real values
+        assert isinstance(pub.map_id, int)
+        assert isinstance(pub.player_x, int)
+        assert isinstance(pub.player_y, int)
+
+    @pytest.mark.asyncio
+    async def test_step_engine_real(self, task_instance):
+        """Test engine step execution with real ROM"""
+        engine = PokemonRedEngine(task_instance)
+        await engine._reset_engine()
+
+        action = {"button": "A", "frames": 1}
+        priv, pub = await engine._step_engine(action)
+
+        assert engine._step_count == 1
+        assert priv.step_count == 1
+        assert isinstance(priv.reward_last_step, float)
+        assert priv.total_reward == engine._total_reward
+
+        # Should have actual game state
+        assert isinstance(pub.map_id, int)
+        assert isinstance(pub.badges, int)
+        assert isinstance(pub.party_hp_current, int)
+
+    @pytest.mark.asyncio
+    async def test_button_sequence_real(self, task_instance):
+        """Test a sequence of button presses with real ROM"""
+        engine = PokemonRedEngine(task_instance)
+        await engine._reset_engine()
+
+        # Try a sequence of different buttons
+        buttons = ["A", "B", "UP", "DOWN", "LEFT", "RIGHT", "START", "SELECT"]
+
+        for i, button in enumerate(buttons):
+            action = {"button": button, "frames": 1}
+            priv, pub = await engine._step_engine(action)
+
+            assert engine._step_count == i + 1
+            assert priv.step_count == i + 1
+
+            # Game state should remain consistent
+            assert isinstance(pub.map_id, int)
+            assert isinstance(pub.player_x, int)
+            assert isinstance(pub.player_y, int)
+
+    @pytest.mark.asyncio
+    async def test_serialization_real(self, task_instance):
+        """Test engine serialization with real ROM"""
+        engine = PokemonRedEngine(task_instance)
+        await engine._reset_engine()
+
+        # Take a few steps to change state
+        await engine._step_engine({"button": "A", "frames": 1})
+        await engine._step_engine({"button": "RIGHT", "frames": 1})
+
+        snapshot = await engine._serialize_engine()
+
+        assert isinstance(snapshot, PokemonRedEngineSnapshot)
+        assert snapshot.total_reward == engine._total_reward
+        assert snapshot.step_count == engine._step_count
+        assert "_save_state_bytes" in snapshot.state_data
+
+    @pytest.mark.asyncio
+    async def test_rom_memory_access(self, task_instance):
+        """Test that we can actually read ROM memory"""
+        engine = PokemonRedEngine(task_instance)
+
+        # Should be able to access memory
+        assert engine.emulator is not None
+        assert hasattr(engine.emulator, "memory")
+
+        # Try reading some memory locations
+        badge_flags = engine.emulator.memory[0xD356]
+        player_x = engine.emulator.memory[0xD362]
+        player_y = engine.emulator.memory[0xD361]
+
+        # Should be valid integers (even if zero initially)
+        assert isinstance(badge_flags, int)
+        assert isinstance(player_x, int)
+        assert isinstance(player_y, int)