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/pokemon_env/types.py

@@ -1,41 +0,0 @@
-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

@@ -1,298 +0,0 @@
-"""
-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

@@ -1,95 +0,0 @@
-[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

@@ -1,204 +0,0 @@
-#!/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())