synth-ai 0.2.13.dev1__py3-none-any.whl → 0.2.13.dev2__py3-none-any.whl

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/pokemon_env/types.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Optional
+from .enums import StatusCondition, PokemonType
+
+@dataclass
+class PokemonData:
+    """Complete Pokemon data structure for Emerald"""
+    species_id: int
+    species_name: str
+    current_hp: int
+    max_hp: int
+    level: int
+    status: StatusCondition
+    type1: PokemonType
+    type2: Optional[PokemonType]
+    moves: list[str]  # Move names
+    move_pp: list[int]  # PP for each move
+    trainer_id: int
+    nickname: Optional[str] = None
+    experience: Optional[int] = None
+    
+    @property
+    def is_asleep(self) -> bool:
+        """Check if the Pokémon is asleep"""
+        return self.status.is_asleep
+        
+    @property
+    def status_name(self) -> str:
+        """Return a human-readable status name"""
+        if self.is_asleep:
+            return "SLEEP"
+        elif self.status & StatusCondition.PARALYSIS:
+            return "PARALYSIS"
+        elif self.status & StatusCondition.FREEZE:
+            return "FREEZE"
+        elif self.status & StatusCondition.BURN:
+            return "BURN"
+        elif self.status & StatusCondition.POISON:
+            return "POISON"
+        else:
+            return "OK"

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/pokemon_env/utils.py

@@ -0,0 +1,298 @@
+"""
+Utility functions for Pokemon Emerald memory reading
+"""
+
+from typing import List, Tuple, Optional
+from .enums import MetatileBehavior, PokemonType, PokemonSpecies, Move
+
+
+def is_passable_behavior(behavior: MetatileBehavior) -> bool:
+    """
+    Check if a metatile behavior allows the player to walk on it
+    
+    Args:
+        behavior: The metatile behavior to check
+        
+    Returns:
+        True if the tile is passable, False otherwise
+    """
+    # List of behaviors that are passable
+    passable_behaviors = {
+        MetatileBehavior.NORMAL,
+        MetatileBehavior.TALL_GRASS,
+        MetatileBehavior.LONG_GRASS,
+        MetatileBehavior.SHORT_GRASS,
+        MetatileBehavior.SAND,
+        MetatileBehavior.ASHGRASS,
+        MetatileBehavior.FOOTPRINTS,
+        MetatileBehavior.PUDDLE,
+        MetatileBehavior.SHALLOW_WATER,
+        MetatileBehavior.ICE,
+        MetatileBehavior.THIN_ICE,
+        MetatileBehavior.CRACKED_ICE,
+        MetatileBehavior.HOT_SPRINGS,
+        MetatileBehavior.MUDDY_SLOPE,
+        MetatileBehavior.BUMPY_SLOPE,
+        MetatileBehavior.CRACKED_FLOOR,
+        MetatileBehavior.VERTICAL_RAIL,
+        MetatileBehavior.HORIZONTAL_RAIL,
+        MetatileBehavior.ISOLATED_VERTICAL_RAIL,
+        MetatileBehavior.ISOLATED_HORIZONTAL_RAIL,
+    }
+    
+    return behavior in passable_behaviors
+
+
+def is_encounter_behavior(behavior: MetatileBehavior) -> bool:
+    """
+    Check if a metatile behavior can trigger wild Pokemon encounters
+    
+    Args:
+        behavior: The metatile behavior to check
+        
+    Returns:
+        True if the tile can trigger encounters, False otherwise
+    """
+    encounter_behaviors = {
+        MetatileBehavior.TALL_GRASS,
+        MetatileBehavior.LONG_GRASS,
+        MetatileBehavior.INDOOR_ENCOUNTER,
+        MetatileBehavior.CAVE,
+        MetatileBehavior.DEEP_WATER,
+        MetatileBehavior.OCEAN_WATER,
+        MetatileBehavior.SHALLOW_WATER,
+    }
+    
+    return behavior in encounter_behaviors
+
+
+def is_surfable_behavior(behavior: MetatileBehavior) -> bool:
+    """
+    Check if a metatile behavior allows surfing
+    
+    Args:
+        behavior: The metatile behavior to check
+        
+    Returns:
+        True if the tile is surfable, False otherwise
+    """
+    surfable_behaviors = {
+        MetatileBehavior.DEEP_WATER,
+        MetatileBehavior.OCEAN_WATER,
+        MetatileBehavior.SHALLOW_WATER,
+        MetatileBehavior.POND_WATER,
+        MetatileBehavior.INTERIOR_DEEP_WATER,
+        MetatileBehavior.SOOTOPOLIS_DEEP_WATER,
+    }
+    
+    return behavior in surfable_behaviors
+
+
+def get_type_effectiveness(attacking_type: PokemonType, defending_type: PokemonType) -> float:
+    """
+    Calculate type effectiveness between two Pokemon types
+    
+    Args:
+        attacking_type: The type of the attacking move
+        defending_type: The type of the defending Pokemon
+        
+    Returns:
+        Effectiveness multiplier (0.0, 0.25, 0.5, 1.0, 2.0, or 4.0)
+    """
+    # Type effectiveness chart (simplified - only includes common types)
+    # This is a basic implementation - a full chart would be much larger
+    effectiveness_chart = {
+        PokemonType.NORMAL: {
+            PokemonType.ROCK: 0.5,
+            PokemonType.GHOST: 0.0,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.FIRE: {
+            PokemonType.FIRE: 0.5,
+            PokemonType.WATER: 0.5,
+            PokemonType.GRASS: 2.0,
+            PokemonType.ICE: 2.0,
+            PokemonType.BUG: 2.0,
+            PokemonType.ROCK: 0.5,
+            PokemonType.DRAGON: 0.5,
+            PokemonType.STEEL: 2.0,
+        },
+        PokemonType.WATER: {
+            PokemonType.FIRE: 2.0,
+            PokemonType.WATER: 0.5,
+            PokemonType.GRASS: 0.5,
+            PokemonType.GROUND: 2.0,
+            PokemonType.ROCK: 2.0,
+            PokemonType.DRAGON: 0.5,
+        },
+        PokemonType.GRASS: {
+            PokemonType.FIRE: 0.5,
+            PokemonType.WATER: 2.0,
+            PokemonType.GRASS: 0.5,
+            PokemonType.POISON: 0.5,
+            PokemonType.GROUND: 2.0,
+            PokemonType.FLYING: 0.5,
+            PokemonType.BUG: 0.5,
+            PokemonType.ROCK: 2.0,
+            PokemonType.DRAGON: 0.5,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.ELECTRIC: {
+            PokemonType.WATER: 2.0,
+            PokemonType.GRASS: 0.5,
+            PokemonType.ELECTRIC: 0.5,
+            PokemonType.GROUND: 0.0,
+            PokemonType.FLYING: 2.0,
+            PokemonType.DRAGON: 0.5,
+        },
+        PokemonType.ICE: {
+            PokemonType.FIRE: 0.5,
+            PokemonType.WATER: 0.5,
+            PokemonType.GRASS: 2.0,
+            PokemonType.ICE: 0.5,
+            PokemonType.GROUND: 2.0,
+            PokemonType.FLYING: 2.0,
+            PokemonType.DRAGON: 2.0,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.FIGHTING: {
+            PokemonType.NORMAL: 2.0,
+            PokemonType.ICE: 2.0,
+            PokemonType.POISON: 0.5,
+            PokemonType.FLYING: 0.5,
+            PokemonType.PSYCHIC: 0.5,
+            PokemonType.BUG: 0.5,
+            PokemonType.ROCK: 2.0,
+            PokemonType.GHOST: 0.0,
+            PokemonType.STEEL: 2.0,
+            PokemonType.DARK: 2.0,
+        },
+        PokemonType.POISON: {
+            PokemonType.GRASS: 2.0,
+            PokemonType.POISON: 0.5,
+            PokemonType.GROUND: 0.5,
+            PokemonType.ROCK: 0.5,
+            PokemonType.GHOST: 0.5,
+            PokemonType.STEEL: 0.0,
+        },
+        PokemonType.GROUND: {
+            PokemonType.FIRE: 2.0,
+            PokemonType.GRASS: 0.5,
+            PokemonType.ELECTRIC: 2.0,
+            PokemonType.POISON: 2.0,
+            PokemonType.FLYING: 0.0,
+            PokemonType.BUG: 0.5,
+            PokemonType.ROCK: 2.0,
+            PokemonType.STEEL: 2.0,
+        },
+        PokemonType.FLYING: {
+            PokemonType.GRASS: 2.0,
+            PokemonType.ELECTRIC: 0.5,
+            PokemonType.FIGHTING: 2.0,
+            PokemonType.BUG: 2.0,
+            PokemonType.ROCK: 0.5,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.PSYCHIC: {
+            PokemonType.FIGHTING: 2.0,
+            PokemonType.POISON: 2.0,
+            PokemonType.PSYCHIC: 0.5,
+            PokemonType.DARK: 0.0,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.BUG: {
+            PokemonType.FIRE: 0.5,
+            PokemonType.GRASS: 2.0,
+            PokemonType.FIGHTING: 0.5,
+            PokemonType.POISON: 0.5,
+            PokemonType.FLYING: 0.5,
+            PokemonType.PSYCHIC: 2.0,
+            PokemonType.GHOST: 0.5,
+            PokemonType.DARK: 2.0,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.ROCK: {
+            PokemonType.FIRE: 2.0,
+            PokemonType.ICE: 2.0,
+            PokemonType.FIGHTING: 0.5,
+            PokemonType.GROUND: 0.5,
+            PokemonType.FLYING: 2.0,
+            PokemonType.BUG: 2.0,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.GHOST: {
+            PokemonType.NORMAL: 0.0,
+            PokemonType.PSYCHIC: 2.0,
+            PokemonType.GHOST: 2.0,
+            PokemonType.DARK: 0.5,
+        },
+        PokemonType.DRAGON: {
+            PokemonType.DRAGON: 2.0,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.DARK: {
+            PokemonType.FIGHTING: 0.5,
+            PokemonType.PSYCHIC: 2.0,
+            PokemonType.GHOST: 2.0,
+            PokemonType.DARK: 0.5,
+            PokemonType.STEEL: 0.5,
+        },
+        PokemonType.STEEL: {
+            PokemonType.FIRE: 0.5,
+            PokemonType.WATER: 0.5,
+            PokemonType.ELECTRIC: 0.5,
+            PokemonType.ICE: 2.0,
+            PokemonType.ROCK: 2.0,
+            PokemonType.STEEL: 0.5,
+        },
+    }
+    
+    if attacking_type in effectiveness_chart and defending_type in effectiveness_chart[attacking_type]:
+        return effectiveness_chart[attacking_type][defending_type]
+    
+    return 1.0  # Normal effectiveness
+
+
+def format_time(hours: int, minutes: int, seconds: int) -> str:
+    """
+    Format game time in a human-readable format
+    
+    Args:
+        hours: Number of hours
+        minutes: Number of minutes
+        seconds: Number of seconds
+        
+    Returns:
+        Formatted time string
+    """
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+
+def format_money(amount: int) -> str:
+    """
+    Format money amount with commas
+    
+    Args:
+        amount: Money amount in cents
+        
+    Returns:
+        Formatted money string
+    """
+    return f"${amount:,}"
+
+
+def get_pokemon_type_names(type1: PokemonType, type2: Optional[PokemonType] = None) -> str:
+    """
+    Get formatted type names for a Pokemon
+    
+    Args:
+        type1: Primary type
+        type2: Secondary type (optional)
+        
+    Returns:
+        Formatted type string
+    """
+    if type2 is None or type1 == type2:
+        return type1.name.replace("_", " ")
+    else:
+        return f"{type1.name.replace('_', ' ')} / {type2.name.replace('_', ' ')}"

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/pyproject.toml

@@ -0,0 +1,95 @@
+[project]
+name = "pokeagent-speedrun"
+version = "0.1.0"
+description = "AI agent that plays Pokémon Emerald using vision-language models"
+readme = "README.md"
+requires-python = ">=3.10,<3.12"
+
+dependencies = [
+    "flask==3.0.2",
+    "flask-socketio==5.3.6",
+    "python-socketio==5.11.1",
+    "python-engineio==4.9.0",
+    "numpy==1.26.4",
+    "opencv-python==4.9.0.80",
+    "pillow==10.2.0",
+    "pygame==2.6.1",
+    "requests>=2.32.2",
+    "python-dotenv==1.0.1",
+    "eventlet==0.35.2",
+    "gevent==23.9.1",
+    "gevent-websocket==0.10.1",
+    "fastapi>=0.104.0",
+    "uvicorn[standard]>=0.24.0",
+    "pydantic>=2.0.0",
+    "mgba==0.10.2",
+    "pyyaml>=5.1",
+    "xxhash",
+    "more-itertools",
+    "pytz>=2020.1",
+    "six>=1.14.0",
+    "colorama",
+    "grpcio>=1.48.2",
+    "protobuf!=4.24.0,<5.0.0,>=3.19.6",
+    "openai==1.90.0",
+    "google-generativeai>=0.3.0",
+    "torch>=2.0.0",
+    "transformers>=4.36.0",
+    "bitsandbytes>=0.41.0",
+    "accelerate>=0.25.0",
+    "sentencepiece>=0.1.99",
+    "cffi>=1.6",
+    "pytesseract>=0.3.10",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["agent", "pokemon_env", "utils", "server"]
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0.0",
+]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+    "UP",  # pyupgrade
+]
+ignore = [
+    "E501",  # line too long
+    "B008",  # do not perform function calls in argument defaults
+    "W191",  # indentation contains tabs
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["agent", "pokemon_env", "utils", "server"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/run.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+Main entry point for the Pokemon Agent.
+This is a streamlined version that focuses on multiprocess mode only.
+"""
+
+import os
+import sys
+import time
+import argparse
+import subprocess
+import signal
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from server.client import run_multiprocess_client
+
+
+def start_server(args):
+    """Start the server process with appropriate arguments"""
+    # Use the same Python executable that's running this script
+    python_exe = sys.executable
+    server_cmd = [python_exe, "-m", "server.app", "--port", str(args.port)]
+    
+    # Pass through server-relevant arguments
+    if args.record:
+        server_cmd.append("--record")
+    
+    if args.load_checkpoint:
+        # Auto-load checkpoint.state when --load-checkpoint is used
+        checkpoint_state = ".pokeagent_cache/checkpoint.state"
+        if os.path.exists(checkpoint_state):
+            server_cmd.extend(["--load-state", checkpoint_state])
+            # Set environment variable to enable LLM checkpoint loading
+            os.environ["LOAD_CHECKPOINT_MODE"] = "true"
+            print(f"🔄 Server will load checkpoint: {checkpoint_state}")
+            print(f"🔄 LLM metrics will be restored from .pokeagent_cache/checkpoint_llm.txt")
+        else:
+            print(f"⚠️ Checkpoint file not found: {checkpoint_state}")
+    elif args.load_state:
+        server_cmd.extend(["--load-state", args.load_state])
+    
+    # Don't pass --manual to server - server should always run in server mode
+    # The --manual flag only affects client behavior
+    
+    if args.no_ocr:
+        server_cmd.append("--no-ocr")
+    
+    # Server always runs headless - display handled by client
+    
+    # Start server as subprocess
+    try:
+        print(f"📋 Server command: {' '.join(server_cmd)}")
+        server_process = subprocess.Popen(
+            server_cmd,
+            universal_newlines=True,
+            bufsize=1
+        )
+        print(f"✅ Server started with PID {server_process.pid}")
+        print("⏳ Waiting 3 seconds for server to initialize...")
+        time.sleep(3)
+        
+        return server_process
+        
+    except Exception as e:
+        print(f"❌ Failed to start server: {e}")
+        return None
+
+
+def start_frame_server():
+    """Start the lightweight frame server for stream.html visualization"""
+    try:
+        frame_cmd = ["python", "-m", "server.frame_server"]
+        frame_process = subprocess.Popen(
+            frame_cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        print(f"🖼️  Frame server started with PID {frame_process.pid}")
+        return frame_process
+    except Exception as e:
+        print(f"⚠️ Could not start frame server: {e}")
+        return None
+
+
+def main():
+    """Main entry point for the Pokemon Agent"""
+    parser = argparse.ArgumentParser(description="Pokemon Emerald AI Agent")
+    
+    # Core arguments
+    parser.add_argument("--rom", type=str, default="Emerald-GBAdvance/rom.gba", 
+                       help="Path to ROM file")
+    parser.add_argument("--port", type=int, default=8000, 
+                       help="Port for web interface")
+    
+    # State loading
+    parser.add_argument("--load-state", type=str, 
+                       help="Load a saved state file on startup")
+    parser.add_argument("--load-checkpoint", action="store_true", 
+                       help="Load from checkpoint files")
+    
+    # Agent configuration
+    parser.add_argument("--backend", type=str, default="gemini", 
+                       help="VLM backend (openai, gemini, local, openrouter)")
+    parser.add_argument("--model-name", type=str, default="gemini-2.5-flash", 
+                       help="Model name to use")
+    parser.add_argument("--simple", action="store_true", 
+                       help="Simple mode: direct frame->action without 4-module architecture")
+    
+    # Operation modes
+    parser.add_argument("--headless", action="store_true", 
+                       help="Run without pygame display (headless)")
+    parser.add_argument("--agent-auto", action="store_true", 
+                       help="Agent acts automatically")
+    parser.add_argument("--manual", action="store_true", 
+                       help="Start in manual mode instead of agent mode")
+    
+    # Features
+    parser.add_argument("--record", action="store_true", 
+                       help="Record video of the gameplay")
+    parser.add_argument("--no-ocr", action="store_true", 
+                       help="Disable OCR dialogue detection")
+    
+    args = parser.parse_args()
+    
+    print("=" * 60)
+    print("🎮 Pokemon Emerald AI Agent")
+    print("=" * 60)
+    
+    server_process = None
+    frame_server_process = None
+    
+    try:
+        # Auto-start server if requested
+        if args.agent_auto or args.manual:
+            print("\n📡 Starting server process...")
+            server_process = start_server(args)
+            
+            if not server_process:
+                print("❌ Failed to start server, exiting...")
+                return 1
+            
+            # Also start frame server for web visualization
+            frame_server_process = start_frame_server()
+        else:
+            print("\n📋 Manual server mode - start server separately with:")
+            print("   python -m server.app --port", args.port)
+            if args.load_state:
+                print(f"   (Add --load-state {args.load_state} to server command)")
+            print("\n⏳ Waiting 3 seconds for manual server startup...")
+            time.sleep(3)
+        
+        # Display configuration
+        print("\n🤖 Agent Configuration:")
+        print(f"   Backend: {args.backend}")
+        print(f"   Model: {args.model_name}")
+        if args.simple:
+            print("   Mode: Simple (direct frame->action)")
+        else:
+            print("   Mode: Four-module architecture")
+        if args.no_ocr:
+            print("   OCR: Disabled")
+        if args.record:
+            print("   Recording: Enabled")
+        
+        print(f"\n🌐 Web Interface: http://127.0.0.1:{args.port}")
+        print(f"🎥 Stream View: http://127.0.0.1:{args.port}/stream.html")
+        
+        print("\n🚀 Starting client...")
+        print("-" * 60)
+        
+        # Run the client
+        success = run_multiprocess_client(server_port=args.port, args=args)
+        
+        return 0 if success else 1
+        
+    except KeyboardInterrupt:
+        print("\n\n🛑 Shutdown requested by user")
+        return 0
+        
+    finally:
+        # Clean up server processes
+        if server_process:
+            print("\n📡 Stopping server process...")
+            server_process.terminate()
+            try:
+                server_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                print("   Force killing server...")
+                server_process.kill()
+        
+        if frame_server_process:
+            print("🖼️  Stopping frame server...")
+            frame_server_process.terminate()
+            try:
+                frame_server_process.wait(timeout=2)
+            except:
+                frame_server_process.kill()
+        
+        print("👋 Goodbye!")
+
+
+if __name__ == "__main__":
+    sys.exit(main())