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/run_tests.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test runner for Pokemon Emerald emulator tests
-
-Usage:
-    python tests/run_tests.py                    # Run all tests
-    python tests/run_tests.py test_fps_adjustment # Run specific test
-"""
-
-import os
-import sys
-import subprocess
-import importlib.util
-
-def run_test(test_name):
-    """Run a specific test"""
-    test_file = f"tests/{test_name}.py"
-    
-    if not os.path.exists(test_file):
-        print(f"❌ Test file not found: {test_file}")
-        return False
-    
-    print(f"🧪 Running test: {test_name}")
-    print("=" * 50)
-    
-    try:
-        # Run the test
-        result = subprocess.run([
-            sys.executable, test_file
-        ], capture_output=False, text=True)
-        
-        if result.returncode == 0:
-            print(f"✅ Test {test_name} passed!")
-            return True
-        else:
-            print(f"❌ Test {test_name} failed!")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Error running test {test_name}: {e}")
-        return False
-
-def run_all_tests():
-    """Run all tests in the tests directory"""
-    print("🧪 Pokemon Emerald Emulator Test Suite")
-    print("=" * 50)
-    
-    # Find all test files
-    test_files = []
-    for file in os.listdir("tests"):
-        if file.startswith("test_") and file.endswith(".py"):
-            test_name = file[:-3]  # Remove .py extension
-            test_files.append(test_name)
-    
-    if not test_files:
-        print("❌ No test files found in tests/ directory")
-        return False
-    
-    print(f"Found {len(test_files)} test(s):")
-    for test in test_files:
-        print(f"  - {test}")
-    print()
-    print("💡 Note: For pytest-style tests, run:")
-    print("   python -m pytest tests/test_fps_adjustment_pytest.py -v")
-    print("   python -m pytest tests/test_server_map_validation.py -v")
-    print("💡 Note: Test state files are located in tests/states/")
-    print("💡 Note: Map reference files are saved in tests/map_references/")
-    print()
-    
-    # Run each test
-    results = []
-    for test in test_files:
-        success = run_test(test)
-        results.append((test, success))
-        print()  # Add spacing between tests
-    
-    # Print summary
-    print("📋 Test Summary")
-    print("=" * 30)
-    
-    passed_count = sum(1 for _, success in results if success)
-    total_count = len(results)
-    
-    for test, success in results:
-        status = "✅ PASS" if success else "❌ FAIL"
-        print(f"{test}: {status}")
-    
-    print(f"\nResults: {passed_count}/{total_count} tests passed")
-    
-    if passed_count == total_count:
-        print("🎉 All tests passed!")
-        return True
-    else:
-        print("⚠️  Some tests failed.")
-        return False
-
-def main():
-    """Main function"""
-    # Check if we're in the right directory
-    if not os.path.exists("server/app.py"):
-        print("❌ Error: This test runner must be run from the project root directory")
-        print("Please run: python tests/run_tests.py")
-        sys.exit(1)
-    
-    # Check if tests directory exists
-    if not os.path.exists("tests"):
-        print("❌ Error: tests/ directory not found")
-        sys.exit(1)
-    
-    # Parse command line arguments
-    if len(sys.argv) > 1:
-        # Run specific test
-        test_name = sys.argv[1]
-        success = run_test(test_name)
-        sys.exit(0 if success else 1)
-    else:
-        # Run all tests
-        success = run_all_tests()
-        sys.exit(0 if success else 1)
-
-if __name__ == "__main__":
-    main() 

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

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-"""
-Pytest for agent functionality (legacy test file)
-"""
-
-import pytest
-import requests
-import json
-import time
-
-class TestAgentDirectAPI:
-    """Test class for agent API endpoints"""
-    
-    base_url = "http://localhost:8080"
-    
-    def test_imports_work(self):
-        """Test that our imports are working"""
-        import agent
-        assert hasattr(agent, 'app')
-        assert hasattr(agent, 'agent_mode')
-        assert hasattr(agent, 'websocket_connections')
-        
-    def test_global_state_initialized(self):
-        """Test that global state variables are properly initialized"""
-        import agent
-        assert agent.agent_mode == True   # Should start in agent mode by default
-        assert agent.agent_auto_enabled == False  # Should start with auto disabled
-        assert isinstance(agent.websocket_connections, set)
-        assert len(agent.websocket_connections) == 0  # Should start empty
-        
-    def test_broadcast_function_exists(self):
-        """Test that broadcast function exists and is callable"""
-        import agent
-        assert hasattr(agent, 'broadcast_state_update')
-        assert callable(agent.broadcast_state_update)
-    
-    @pytest.mark.skip(reason="Requires running server")
-    def test_status_endpoint(self):
-        """Test the /status endpoint"""
-        try:
-            response = requests.get(f"{self.base_url}/status", timeout=2)
-            assert response.status_code == 200
-            data = response.json()
-            assert "step" in data
-            assert "agent_initialized" in data
-        except requests.exceptions.ConnectionError:
-            pytest.skip("agent server not running")
-    
-    @pytest.mark.skip(reason="Requires running server") 
-    def test_toggle_mode_endpoint(self):
-        """Test the /toggle_mode endpoint"""
-        try:
-            response = requests.post(f"{self.base_url}/toggle_mode", timeout=2)
-            assert response.status_code == 200
-            data = response.json()
-            assert "mode" in data
-            assert "agent_mode" in data
-            assert data["mode"] in ["MANUAL", "AGENT"]
-        except requests.exceptions.ConnectionError:
-            pytest.skip("agent server not running")
-    
-    @pytest.mark.skip(reason="Requires running server")
-    def test_toggle_auto_endpoint(self):
-        """Test the /toggle_auto endpoint"""
-        try:
-            response = requests.post(f"{self.base_url}/toggle_auto", timeout=2)
-            assert response.status_code == 200
-            data = response.json()
-            assert "auto_enabled" in data
-            assert "status" in data
-            assert data["status"] in ["ENABLED", "DISABLED"]
-        except requests.exceptions.ConnectionError:
-            pytest.skip("agent server not running")
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

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

@@ -1,413 +0,0 @@
-#!/usr/bin/env python3
-"""
-Pytest for Agent Prompts Validation
-
-Tests that validate the actual prompt outputs from agent modules:
-- action.py: Action decision prompts
-- memory.py: Memory context generation
-- perception.py: Observation and scene analysis
-- planning.py: Strategic planning prompts
-
-This test validates that the agent modules generate proper prompts without "Unknown" values.
-"""
-
-import pytest
-import json
-import sys
-import os
-import requests
-import time
-import subprocess
-from typing import Dict, Any, List, Set
-from unittest.mock import Mock, patch
-from pathlib import Path
-
-# Add the project root to the path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-# Import agent modules
-from agent.action import action_step
-from agent.memory import memory_step, extract_key_state_info
-from agent.perception import perception_step
-from agent.planning import planning_step
-from utils.vlm import VLM
-from utils.state_formatter import format_state_for_llm, format_state_summary
-
-
-class TestAgentPrompts:
-    """Test class for agent prompts validation"""
-    
-    @pytest.fixture
-    def server_url(self):
-        """Server URL for testing"""
-        return "http://localhost:8000"
-    
-    @pytest.fixture
-    def mock_vlm(self):
-        """Create a mock VLM that captures prompts and returns reasonable responses"""
-        mock_vlm = Mock(spec=VLM)
-        
-        def mock_get_query(frame, prompt, context=""):
-            # Capture the prompt for analysis
-            if not hasattr(mock_vlm, 'captured_prompts'):
-                mock_vlm.captured_prompts = []
-            mock_vlm.captured_prompts.append({
-                'context': context,
-                'prompt': prompt,
-                'frame': frame is not None
-            })
-            
-            # Return reasonable responses based on context
-            if "PERCEPTION" in context:
-                return "I can see the player character on a grassy route with trees and paths."
-            elif "ACTION" in context:
-                return "UP"
-            elif "PLANNING" in context:
-                return "Continue exploring the route and look for items or trainers."
-            elif "MEMORY" in context:
-                return "Updated memory context with current observations."
-            else:
-                return "Default response"
-        
-        def mock_get_text_query(prompt, context=""):
-            # Capture the prompt for analysis
-            if not hasattr(mock_vlm, 'captured_prompts'):
-                mock_vlm.captured_prompts = []
-            mock_vlm.captured_prompts.append({
-                'context': context,
-                'prompt': prompt,
-                'frame': False
-            })
-            
-            # Return reasonable responses based on context
-            if "ACTION" in context:
-                return "UP"
-            elif "PLANNING" in context:
-                return "Continue exploring the route and look for items or trainers."
-            elif "MEMORY" in context:
-                return "Updated memory context with current observations."
-            else:
-                return "Default response"
-        
-        mock_vlm.get_query = mock_get_query
-        mock_vlm.get_text_query = mock_get_text_query
-        
-        return mock_vlm
-    
-    def find_state_files(self):
-        """Find all .state files in the tests/states directory"""
-        states_dir = Path(__file__).parent / "states"
-        if not states_dir.exists():
-            return []
-        
-        state_files = list(states_dir.glob("*.state"))
-        return sorted(state_files)
-    
-    def start_server_with_state(self, state_file_path: str):
-        """Start the server with a specific state file"""
-        import subprocess
-        
-        # Kill any existing server processes
-        try:
-            subprocess.run(["pkill", "-f", "server.app"], check=False)
-            time.sleep(1)
-        except:
-            pass
-        
-        # Start new server
-        server_process = subprocess.Popen([
-            "conda", "run", "-n", "mgba", "python", "-m", "server.app", 
-            "--load-state", state_file_path
-        ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        
-        # Wait for server to start
-        time.sleep(3)
-        
-        return server_process
-    
-    def stop_server(self, server_process):
-        """Stop the server"""
-        if server_process:
-            try:
-                server_process.terminate()
-                server_process.wait(timeout=5)
-            except:
-                server_process.kill()
-    
-    def get_state_from_server(self, server_url: str) -> Dict[str, Any]:
-        """Get state data from the server"""
-        try:
-            response = requests.get(f"{server_url}/state", timeout=10)
-            if response.status_code == 200:
-                return response.json()
-            else:
-                return {}
-        except Exception:
-            return {}
-    
-    def test_action_module_prompts(self, mock_vlm, server_url):
-        """Test that action module generates proper prompts without 'Unknown' values"""
-        state_files = self.find_state_files()
-        
-        for state_file in state_files:
-            print(f"\nTesting ACTION module with {state_file}")
-            
-            # Start server
-            server_process = self.start_server_with_state(str(state_file))
-            
-            try:
-                # Get state data
-                state_data = self.get_state_from_server(server_url)
-                if not state_data:
-                    pytest.skip(f"Could not get state data for {state_file}")
-                
-                # Mock inputs for action_step
-                memory_context = "Test memory context"
-                current_plan = "Test plan"
-                latest_observation = "Test observation"
-                frame = None
-                recent_actions = ["UP", "A", "RIGHT"]
-                
-                # Call action_step
-                actions = action_step(memory_context, current_plan, latest_observation, frame, state_data, recent_actions, mock_vlm)
-                
-                # Check captured prompts
-                action_prompts = [p for p in mock_vlm.captured_prompts if "ACTION" in p['context']]
-                
-                assert action_prompts, f"No action prompts captured for {state_file}"
-                
-                # Analyze the action prompt for issues
-                action_prompt = action_prompts[0]['prompt']
-                
-                # Check for "Unknown" values in the prompt
-                assert "Unknown" not in action_prompt, f"Action prompt contains 'Unknown' values in {state_file}"
-                
-                # Check for required sections
-                required_sections = ["COMPREHENSIVE GAME STATE DATA", "ENHANCED ACTION CONTEXT", "ACTION DECISION TASK"]
-                for section in required_sections:
-                    assert section in action_prompt, f"Action prompt missing section '{section}' in {state_file}"
-                
-                # Check that actions were returned
-                assert actions, f"Action module returned no actions for {state_file}"
-                assert isinstance(actions, list), f"Action module returned non-list actions for {state_file}"
-                
-            finally:
-                self.stop_server(server_process)
-    
-    def test_memory_module_prompts(self, mock_vlm, server_url):
-        """Test that memory module generates proper prompts without 'Unknown' values"""
-        state_files = self.find_state_files()
-        
-        for state_file in state_files:
-            print(f"\nTesting MEMORY module with {state_file}")
-            
-            # Start server
-            server_process = self.start_server_with_state(str(state_file))
-            
-            try:
-                # Get state data
-                state_data = self.get_state_from_server(server_url)
-                if not state_data:
-                    pytest.skip(f"Could not get state data for {state_file}")
-                
-                # Test extract_key_state_info function
-                key_info = extract_key_state_info(state_data)
-                
-                # Check for "Unknown" values in key info
-                assert "Unknown" not in str(key_info), f"Memory key_info contains 'Unknown' values in {state_file}"
-                
-                # Check for required fields
-                required_fields = ['state_summary', 'player_name', 'money', 'current_map', 'in_battle', 'party_health']
-                for field in required_fields:
-                    assert field in key_info, f"Memory key_info missing field '{field}' in {state_file}"
-                
-                # Test memory_step function
-                memory_context = "Test memory context"
-                current_plan = "Test plan"
-                recent_actions = ["UP", "A", "RIGHT"]
-                observation_buffer = [
-                    {
-                        "frame_id": 1,
-                        "observation": "Test observation",
-                        "state": state_data
-                    }
-                ]
-                
-                # Call memory_step
-                updated_memory = memory_step(memory_context, current_plan, recent_actions, observation_buffer, mock_vlm)
-                
-                # Check for "Unknown" values in memory context
-                assert "Unknown" not in updated_memory, f"Memory context contains 'Unknown' values in {state_file}"
-                
-                # Check for required sections
-                required_sections = ["COMPREHENSIVE MEMORY CONTEXT", "CURRENT STATE", "CURRENT PLAN", "KEY EVENTS", "RECENT MEMORY"]
-                for section in required_sections:
-                    assert section in updated_memory, f"Memory context missing section '{section}' in {state_file}"
-                
-                # Check that memory context is not empty
-                assert len(updated_memory.strip()) > 100, f"Memory context seems too short in {state_file}"
-                
-            finally:
-                self.stop_server(server_process)
-    
-    def test_perception_module_prompts(self, mock_vlm, server_url):
-        """Test that perception module generates proper prompts without 'Unknown' values"""
-        state_files = self.find_state_files()
-        
-        for state_file in state_files:
-            print(f"\nTesting PERCEPTION module with {state_file}")
-            
-            # Start server
-            server_process = self.start_server_with_state(str(state_file))
-            
-            try:
-                # Get state data
-                state_data = self.get_state_from_server(server_url)
-                if not state_data:
-                    pytest.skip(f"Could not get state data for {state_file}")
-                
-                # Mock frame
-                frame = None
-                
-                # Call perception_step
-                observation, slow_thinking = perception_step(frame, state_data, mock_vlm)
-                
-                # Check captured prompts
-                perception_prompts = [p for p in mock_vlm.captured_prompts if "PERCEPTION" in p['context']]
-                
-                assert perception_prompts, f"No perception prompts captured for {state_file}"
-                
-                # Analyze the perception prompt for issues
-                perception_prompt = perception_prompts[0]['prompt']
-                
-                # Check for "Unknown" values in the prompt
-                assert "Unknown" not in perception_prompt, f"Perception prompt contains 'Unknown' values in {state_file}"
-                
-                # Check for required sections
-                required_sections = ["COMPREHENSIVE GAME STATE DATA", "VISUAL ANALYSIS TASK"]
-                for section in required_sections:
-                    assert section in perception_prompt, f"Perception prompt missing section '{section}' in {state_file}"
-                
-                # Check for analysis instructions
-                analysis_keywords = ["CUTSCENE", "MAP", "BATTLE", "DIALOGUE", "MENU"]
-                found_keywords = [kw for kw in analysis_keywords if kw in perception_prompt]
-                assert len(found_keywords) >= 3, f"Perception prompt missing analysis keywords in {state_file}. Found: {found_keywords}"
-                
-                # Check that observation was returned
-                assert observation, f"Perception module returned no observation for {state_file}"
-                assert isinstance(observation, dict), f"Perception module returned non-dict observation for {state_file}"
-                
-                # Check that slow_thinking is boolean
-                assert isinstance(slow_thinking, bool), f"Perception module returned non-boolean slow_thinking for {state_file}"
-                
-            finally:
-                self.stop_server(server_process)
-    
-    def test_planning_module_prompts(self, mock_vlm, server_url):
-        """Test that planning module generates proper prompts without 'Unknown' values"""
-        state_files = self.find_state_files()
-        
-        for state_file in state_files:
-            print(f"\nTesting PLANNING module with {state_file}")
-            
-            # Start server
-            server_process = self.start_server_with_state(str(state_file))
-            
-            try:
-                # Get state data
-                state_data = self.get_state_from_server(server_url)
-                if not state_data:
-                    pytest.skip(f"Could not get state data for {state_file}")
-                
-                # Mock inputs for planning_step
-                memory_context = "Test memory context"
-                current_plan = None  # Start with no plan
-                slow_thinking_needed = True
-                
-                # Call planning_step
-                plan = planning_step(memory_context, current_plan, slow_thinking_needed, state_data, mock_vlm)
-                
-                # Check captured prompts
-                planning_prompts = [p for p in mock_vlm.captured_prompts if "PLANNING" in p['context']]
-                
-                assert planning_prompts, f"No planning prompts captured for {state_file}"
-                
-                # Analyze the planning prompt for issues
-                planning_prompt = planning_prompts[0]['prompt']
-                
-                # Check for "Unknown" values in the prompt
-                assert "Unknown" not in planning_prompt, f"Planning prompt contains 'Unknown' values in {state_file}"
-                
-                # Check for required sections
-                required_sections = ["COMPREHENSIVE GAME STATE DATA", "STRATEGIC PLANNING TASK"]
-                for section in required_sections:
-                    assert section in planning_prompt, f"Planning prompt missing section '{section}' in {state_file}"
-                
-                # Check for planning instructions
-                planning_keywords = ["IMMEDIATE GOAL", "SHORT-TERM OBJECTIVES", "LONG-TERM STRATEGY", "EFFICIENCY NOTES"]
-                found_keywords = [kw for kw in planning_keywords if kw in planning_prompt]
-                assert len(found_keywords) >= 3, f"Planning prompt missing planning keywords in {state_file}. Found: {found_keywords}"
-                
-                # Check that plan was returned
-                assert plan, f"Planning module returned no plan for {state_file}"
-                assert isinstance(plan, str), f"Planning module returned non-string plan for {state_file}"
-                
-            finally:
-                self.stop_server(server_process)
-    
-    def test_all_modules_integration(self, mock_vlm, server_url):
-        """Test that all modules work together without 'Unknown' values"""
-        state_files = self.find_state_files()
-        
-        for state_file in state_files:
-            print(f"\nTesting ALL MODULES integration with {state_file}")
-            
-            # Start server
-            server_process = self.start_server_with_state(str(state_file))
-            
-            try:
-                # Get state data
-                state_data = self.get_state_from_server(server_url)
-                if not state_data:
-                    pytest.skip(f"Could not get state data for {state_file}")
-                
-                # Test all modules in sequence
-                memory_context = "Test memory context"
-                current_plan = None
-                latest_observation = "Test observation"
-                frame = None
-                recent_actions = ["UP", "A", "RIGHT"]
-                observation_buffer = [
-                    {
-                        "frame_id": 1,
-                        "observation": "Test observation",
-                        "state": state_data
-                    }
-                ]
-                
-                # 1. Perception
-                observation, slow_thinking = perception_step(frame, state_data, mock_vlm)
-                assert observation and isinstance(observation, dict)
-                
-                # 2. Memory
-                updated_memory = memory_step(memory_context, current_plan, recent_actions, observation_buffer, mock_vlm)
-                assert "Unknown" not in updated_memory
-                
-                # 3. Planning
-                plan = planning_step(updated_memory, current_plan, slow_thinking, state_data, mock_vlm)
-                assert plan and isinstance(plan, str)
-                
-                # 4. Action
-                actions = action_step(updated_memory, plan, observation, frame, state_data, recent_actions, mock_vlm)
-                assert actions and isinstance(actions, list)
-                
-                # Check that no prompts contain "Unknown"
-                for prompt_data in mock_vlm.captured_prompts:
-                    assert "Unknown" not in prompt_data['prompt'], f"Found 'Unknown' in {prompt_data['context']} prompt for {state_file}"
-                
-            finally:
-                self.stop_server(server_process)
-
-
-if __name__ == "__main__":
-    pytest.main([__file__])