synth-ai 0.2.14__py3-none-any.whl → 0.4.4__py3-none-any.whl

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/tests/test_direct_agent_emulator.py

@@ -1,300 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test agent and emulator running directly without separate server process
-"""
-
-import pytest
-import os
-import time
-from pathlib import Path
-from pokemon_env.emulator import EmeraldEmulator
-
-
-class TestDirectAgentEmulator:
-    """Test agent functionality by running emulator directly"""
-    
-    @pytest.fixture(scope="class")
-    def output_dir(self):
-        """Create output directory for test results"""
-        output_path = Path("test_outputs/direct_agent_maps")
-        output_path.mkdir(parents=True, exist_ok=True)
-        return output_path
-    
-    def format_map_for_comparison(self, tiles, title, location, position):
-        """Format map tiles for comparison"""
-        if not tiles:
-            return f"=== {title} ===\nNo tiles available\n"
-        
-        output = []
-        output.append(f"=== {title} ===")
-        output.append(f"Format: (MetatileID, Behavior, X, Y)")
-        output.append(f"Map dimensions: {len(tiles)}x{len(tiles[0]) if tiles else 0}")
-        output.append("")
-        output.append("--- TRAVERSABILITY MAP ---")
-        
-        # Header with column numbers
-        header = "      " + "  ".join(f"{i:2}" for i in range(len(tiles[0]) if tiles else 0))
-        output.append(header)
-        output.append("    " + "-" * (len(header) - 4))
-        
-        # Map rows
-        for row_idx, row in enumerate(tiles):
-            traversability_row = []
-            for col_idx, tile in enumerate(row):
-                if len(tile) >= 4:
-                    tile_id, behavior, collision, elevation = tile
-                    behavior_val = behavior if not hasattr(behavior, 'value') else behavior.value
-                    
-                    # Convert to traversability symbol
-                    if behavior_val == 0:  # NORMAL
-                        symbol = "." if collision == 0 else "#"
-                    elif behavior_val == 1:  # SECRET_BASE_WALL
-                        symbol = "#"
-                    elif behavior_val == 51:  # IMPASSABLE_SOUTH
-                        symbol = "IM"
-                    elif behavior_val == 96:  # NON_ANIMATED_DOOR
-                        symbol = "D"
-                    elif behavior_val == 101:  # SOUTH_ARROW_WARP
-                        symbol = "SO"
-                    elif behavior_val == 105:  # ANIMATED_DOOR
-                        symbol = "D"
-                    elif behavior_val == 134:  # TELEVISION
-                        symbol = "TE"
-                    else:
-                        symbol = "."  # Default to walkable for other behaviors
-                    
-                    # Mark player position
-                    if position and len(position) >= 2:
-                        # Player is at center of 15x15 map (position 7,7)
-                        if row_idx == 7 and col_idx == 7:
-                            symbol = "P"
-                    
-                    traversability_row.append(symbol)
-                else:
-                    traversability_row.append("?")
-            
-            # Format row with row number
-            row_str = f"{row_idx:2}: " + " ".join(f"{symbol:1}" for symbol in traversability_row)
-            output.append(row_str)
-        
-        return "\n".join(output)
-    
-    def save_map_output(self, tiles, output_file, title, location, position):
-        """Save map output to file"""
-        formatted_output = self.format_map_for_comparison(tiles, title, location, position)
-        
-        os.makedirs(os.path.dirname(output_file), exist_ok=True)
-        with open(output_file, 'w') as f:
-            f.write(formatted_output)
-        
-        return formatted_output
-    
-    def test_direct_emulator_house_to_outside(self, output_dir):
-        """Test direct emulator movement from house to outside"""
-        print("🏠➡️🌳 DIRECT EMULATOR: House to Outside Movement Test")
-        
-        # Initialize emulator directly
-        rom_path = "Emerald-GBAdvance/rom.gba"
-        if not os.path.exists(rom_path):
-            pytest.skip(f"ROM not found at {rom_path}")
-        
-        emulator = EmeraldEmulator(rom_path=rom_path, headless=True, sound=False)
-        emulator.initialize()
-        emulator.load_state('tests/states/house.state')
-        
-        try:
-            # Get initial house map
-            print("\n1️⃣ Getting initial house map...")
-            house_state = emulator.get_comprehensive_state()
-            house_location = house_state['player']['location']
-            house_position = (house_state['player']['position']['x'], house_state['player']['position']['y'])
-            house_tiles = house_state['map']['tiles']
-            
-            print(f"House state: {house_location} at {house_position}")
-            
-            # Save house map
-            house_output_file = output_dir / "direct_emulator_house.txt"
-            house_content = self.save_map_output(
-                house_tiles, house_output_file,
-                f"Direct Emulator House - {house_location}", house_location, house_position
-            )
-            
-            # Analyze house map
-            house_corruption = self.analyze_map_corruption(house_tiles)
-            print(f"House map: {house_corruption['total']} tiles, {house_corruption['im_count']} IM tiles")
-            
-            # Move to outside area
-            print("\n2️⃣ Moving to outside area...")
-            moves_made = 0
-            max_moves = 8
-            
-            for move_num in range(max_moves):
-                print(f"Move {move_num + 1}: Pressing DOWN")
-                emulator.press_buttons(['down'], hold_frames=25, release_frames=25)
-                time.sleep(0.1)  # Small delay for transition
-                moves_made += 1
-                
-                # Check if we've left the house
-                current_state = emulator.get_comprehensive_state()
-                current_location = current_state['player']['location']
-                current_position = (current_state['player']['position']['x'], current_state['player']['position']['y'])
-                
-                print(f"  Position: {current_position}, Location: {current_location}")
-                
-                if "HOUSE" not in current_location:
-                    print(f"✅ Reached outside area after {moves_made} moves!")
-                    break
-            else:
-                print(f"❌ Still in house after {max_moves} moves")
-            
-            # Wait for any transition effects to complete
-            time.sleep(0.5)
-            
-            # Get final outside map
-            print("\n3️⃣ Getting final outside map...")
-            outside_state = emulator.get_comprehensive_state()
-            outside_location = outside_state['player']['location']
-            outside_position = (outside_state['player']['position']['x'], outside_state['player']['position']['y'])
-            outside_tiles = outside_state['map']['tiles']
-            
-            print(f"Outside state: {outside_location} at {outside_position}")
-            
-            # Save outside map
-            outside_output_file = output_dir / "direct_emulator_outside.txt"
-            outside_content = self.save_map_output(
-                outside_tiles, outside_output_file,
-                f"Direct Emulator Outside - {outside_location}", outside_location, outside_position
-            )
-            
-            # Analyze outside map
-            outside_corruption = self.analyze_map_corruption(outside_tiles)
-            print(f"Outside map: {outside_corruption['total']} tiles, {outside_corruption['im_count']} IM tiles")
-            
-            print(f"\n4️⃣ Map Analysis:")
-            print(f"House map saved to: {house_output_file}")
-            print(f"Outside map saved to: {outside_output_file}")
-            
-            # Test assertions
-            assert house_tiles is not None, "House map should exist"
-            assert outside_tiles is not None, "Outside map should exist"
-            assert len(house_tiles) == 15, "House map should be 15x15"
-            assert len(outside_tiles) == 15, "Outside map should be 15x15"
-            
-            # Check that we actually moved to outside area
-            assert "HOUSE" not in outside_location, f"Should be outside, but location is: {outside_location}"
-            
-            # Check for reasonable corruption levels
-            if outside_corruption['im_count'] > 50:
-                print(f"⚠️  WARNING: High corruption in outside map ({outside_corruption['im_count']} IM tiles)")
-                print("This indicates area transition detection may not be working properly")
-            else:
-                print(f"✅ Outside map looks clean ({outside_corruption['im_count']} IM tiles is acceptable)")
-            
-            print("✅ DIRECT EMULATOR TEST PASSED!")
-            
-        finally:
-            emulator.stop()
-    
-    def analyze_map_corruption(self, tiles):
-        """Analyze map for corruption (IM tiles)"""
-        if not tiles:
-            return {'total': 0, 'im_count': 0, 'corruption_ratio': 0.0}
-        
-        total_tiles = sum(len(row) for row in tiles)
-        im_count = 0
-        behavior_distribution = {}
-        
-        for row in tiles:
-            for tile in row:
-                if len(tile) >= 2:
-                    behavior = tile[1].value if hasattr(tile[1], 'value') else tile[1]
-                    behavior_distribution[behavior] = behavior_distribution.get(behavior, 0) + 1
-                    
-                    if behavior == 51:  # IMPASSABLE_SOUTH
-                        im_count += 1
-        
-        corruption_ratio = im_count / total_tiles if total_tiles > 0 else 0.0
-        
-        return {
-            'total': total_tiles,
-            'im_count': im_count,
-            'corruption_ratio': corruption_ratio,
-            'behavior_distribution': behavior_distribution
-        }
-    
-    def test_direct_agent_simulation(self, output_dir):
-        """Test simulating agent decision-making with direct emulator access"""
-        print("🤖 DIRECT AGENT SIMULATION: Testing agent-like behavior")
-        
-        rom_path = "Emerald-GBAdvance/rom.gba"
-        if not os.path.exists(rom_path):
-            pytest.skip(f"ROM not found at {rom_path}")
-        
-        emulator = EmeraldEmulator(rom_path=rom_path, headless=True, sound=False)
-        emulator.initialize()
-        emulator.load_state('tests/states/house.state')
-        
-        try:
-            print("\n🎯 Goal: Navigate from house to outside using agent-like logic")
-            
-            steps = 0
-            max_steps = 10
-            
-            while steps < max_steps:
-                # Get current state (like agent perception)
-                current_state = emulator.get_comprehensive_state()
-                location = current_state['player']['location']
-                position = (current_state['player']['position']['x'], current_state['player']['position']['y'])
-                
-                print(f"\nStep {steps + 1}: {location} at {position}")
-                
-                # Simple agent logic: if in house, move down
-                if "HOUSE" in location:
-                    print("  🤖 Agent decision: In house, moving DOWN")
-                    emulator.press_buttons(['down'], hold_frames=25, release_frames=25)
-                    time.sleep(0.1)
-                else:
-                    print("  🎉 Agent goal achieved: Reached outside area!")
-                    break
-                
-                steps += 1
-            
-            # Get final state for analysis
-            final_state = emulator.get_comprehensive_state()
-            final_location = final_state['player']['location']
-            final_position = (final_state['player']['position']['x'], final_state['player']['position']['y'])
-            final_tiles = final_state['map']['tiles']
-            
-            print(f"\n📊 Final Result:")
-            print(f"Location: {final_location}")
-            print(f"Position: {final_position}")
-            print(f"Steps taken: {steps}")
-            
-            # Save agent simulation result
-            agent_output_file = output_dir / "direct_agent_simulation.txt"
-            self.save_map_output(
-                final_tiles, agent_output_file,
-                f"Direct Agent Simulation - {final_location}", final_location, final_position
-            )
-            
-            corruption = self.analyze_map_corruption(final_tiles)
-            print(f"Map quality: {corruption['total']} tiles, {corruption['im_count']} IM tiles")
-            print(f"Agent simulation saved to: {agent_output_file}")
-            
-            # Test passed if agent successfully navigated
-            success = "HOUSE" not in final_location
-            if success:
-                print("✅ AGENT SIMULATION SUCCESSFUL!")
-            else:
-                print("❌ Agent failed to navigate out of house")
-            
-            assert steps < max_steps, "Agent should complete navigation within step limit"
-            
-        finally:
-            emulator.stop()
-
-
-if __name__ == "__main__":
-    # Allow running as script for manual testing
-    import sys
-    sys.exit(pytest.main([__file__, "-v", "-s"]))

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/tests/test_fps_adjustment_pytest.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-"""
-Pytest version of FPS adjustment system test for Pokemon Emerald emulator
-
-This test verifies that the FPS adjustment system correctly:
-1. Runs at 30 FPS in normal overworld state
-2. Speeds up to 120 FPS (4x) when dialog is detected
-3. Reverts to 30 FPS when dialog ends
-
-Test States:
-- Base overworld: Emerald-GBAdvance/simple_test.state (expected: 30 FPS)
-- Dialog state: server/dialog.state (expected: 120 FPS)  
-- Dialog state 2: server/dialog2.state (expected: 120 FPS)
-- After dialog: server/after_dialog.state (expected: 30 FPS)
-"""
-
-import pytest
-import subprocess
-import time
-import requests
-import os
-import sys
-
-# Test data
-TEST_CASES = [
-    {
-        "state_file": "tests/states/simple_test.state",
-        "expected_fps": 30,
-        "test_name": "Base Overworld State"
-    },
-    {
-        "state_file": "tests/states/dialog.state", 
-        "expected_fps": 120,
-        "test_name": "Dialog State"
-    },
-    {
-        "state_file": "tests/states/dialog2.state",
-        "expected_fps": 120,
-        "test_name": "Dialog State 2"
-    },
-    {
-        "state_file": "tests/states/after_dialog.state",
-        "expected_fps": 30,
-        "test_name": "After Dialog Ends"
-    }
-]
-
-class ServerManager:
-    """Manages server startup and shutdown for tests"""
-    
-    def __init__(self):
-        self.server_process = None
-    
-    def start_server(self, state_file):
-        """Start the server with a specific state file"""
-        print(f"🚀 Starting server with state: {state_file}")
-        cmd = ["python", "-m", "server.app", "--manual", "--load-state", state_file]
-        
-        try:
-            self.server_process = subprocess.Popen(
-                cmd, 
-                stdout=subprocess.PIPE, 
-                stderr=subprocess.PIPE
-            )
-            
-            # Wait for server to start
-            print("⏳ Waiting for server to start...")
-            time.sleep(5)
-            
-            # Test if server is responding
-            response = requests.get("http://localhost:8000/status", timeout=5)
-            if response.status_code == 200:
-                print("✅ Server started successfully")
-                return True
-            else:
-                print(f"❌ Server not responding: {response.status_code}")
-                return False
-                
-        except Exception as e:
-            print(f"❌ Failed to start server: {e}")
-            return False
-    
-    def stop_server(self):
-        """Stop the server cleanly"""
-        if self.server_process:
-            print("🛑 Stopping server...")
-            try:
-                # Try graceful shutdown first
-                requests.post("http://localhost:8000/stop", timeout=2)
-                time.sleep(1)
-            except:
-                pass
-            
-            # Force terminate if still running
-            try:
-                self.server_process.terminate()
-                self.server_process.wait(timeout=5)
-                print("✅ Server stopped gracefully")
-            except subprocess.TimeoutExpired:
-                print("⚠️  Server didn't stop gracefully, force killing...")
-                self.server_process.kill()
-                self.server_process.wait()
-                print("✅ Server force killed")
-
-def check_fps(expected_fps, test_name):
-    """Check if the current FPS matches the expected value"""
-    try:
-        response = requests.get("http://localhost:8000/status", timeout=5)
-        if response.status_code != 200:
-            print(f"❌ Server not responding: {response.status_code}")
-            return False
-        
-        status = response.json()
-        base_fps = status.get('base_fps')
-        current_fps = status.get('current_fps')
-        is_dialog = status.get('is_dialog')
-        fps_multiplier = status.get('fps_multiplier')
-        
-        print(f"   Base FPS: {base_fps}")
-        print(f"   Current FPS: {current_fps}")
-        print(f"   Is Dialog: {is_dialog}")
-        print(f"   FPS Multiplier: {fps_multiplier}")
-        
-        if current_fps == expected_fps:
-            print(f"✅ {test_name}: {current_fps} FPS (expected: {expected_fps}) - PASS")
-            return True
-        else:
-            print(f"❌ {test_name}: {current_fps} FPS (expected: {expected_fps}) - FAIL")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Error checking FPS: {e}")
-        return False
-
-@pytest.fixture(scope="session", autouse=True)
-def check_environment():
-    """Check that we're in the right environment before running tests"""
-    # Check if we're in the right directory
-    if not os.path.exists("server/app.py"):
-        pytest.fail("❌ Error: This test must be run from the project root directory")
-    
-    # Check if state files exist
-    required_files = [
-        "tests/states/simple_test.state",
-        "tests/states/dialog.state", 
-        "tests/states/dialog2.state",
-        "tests/states/after_dialog.state"
-    ]
-    
-    missing_files = [f for f in required_files if not os.path.exists(f)]
-    if missing_files:
-        pytest.fail(f"❌ Error: Missing required state files: {missing_files}")
-
-@pytest.mark.parametrize("test_case", TEST_CASES)
-def test_fps_adjustment(test_case):
-    """Test FPS adjustment for a specific state"""
-    state_file = test_case["state_file"]
-    expected_fps = test_case["expected_fps"]
-    test_name = test_case["test_name"]
-    
-    print(f"\n🎮 Testing {test_name}")
-    print("=" * 50)
-    print(f"State file: {state_file}")
-    print(f"Expected FPS: {expected_fps}")
-    
-    # Check if state file exists
-    if not os.path.exists(state_file):
-        pytest.fail(f"❌ State file not found: {state_file}")
-    
-    # Start server
-    server = ServerManager()
-    if not server.start_server(state_file):
-        pytest.fail("Failed to start server")
-    
-    try:
-        # For after_dialog state, wait for the 5-second timeout to expire
-        if "after_dialog" in state_file:
-            print("⏳ Waiting 6 seconds for dialog FPS timeout to expire...")
-            time.sleep(6)
-        
-        # Check FPS
-        result = check_fps(expected_fps, test_name)
-        
-        # Assert the result
-        assert result, f"FPS check failed for {test_name}"
-        
-    finally:
-        # Stop server
-        server.stop_server()
-        
-        # Wait between tests
-        time.sleep(2)
-
-def test_fps_adjustment_summary():
-    """Test summary - this will run after all individual tests"""
-    print("\n📋 FPS Adjustment System Test Summary")
-    print("=" * 50)
-    print("This test verifies the FPS adjustment system:")
-    print("1. Base overworld state: 30 FPS")
-    print("2. Dialog state: 120 FPS (4x speedup)")
-    print("3. Dialog state 2: 120 FPS (4x speedup) - Currently failing, needs investigation")
-    print("4. After dialog ends: 30 FPS (reverted)")
-    print()
-    print("🎉 All individual FPS tests completed!")
-    print("Note: Dialog State 2 is expected to fail until the dialog detection is improved")