run_visualizer.py

#!/usr/bin/env python3
"""
Quick launcher for the Slither.io visualizer
Automatically creates and manages a virtual environment if needed.
"""

import sys
import subprocess
import os
from pathlib import Path
from urllib import error, request
import json

VENV_DIR = Path(__file__).parent / "visualizer_venv"
REQUIREMENTS_FILE = Path(__file__).parent / "visualizer_requirements.txt"
KNOWN_SERVER_HOSTS = [
    ("Localhost", "http://127.0.0.1:5055"),
    ("VPS", "http://81.17.103.197:5055")
]

def is_in_venv():
    """Check if we're running inside a virtual environment"""
    return hasattr(sys, 'real_prefix') or (
        hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
    )

def create_venv():
    """Create a virtual environment"""
    print("Creating virtual environment for visualizer...")
    try:
        subprocess.check_call([sys.executable, "-m", "venv", str(VENV_DIR)])
        print("✓ Virtual environment created")
        return True
    except subprocess.CalledProcessError as e:
        print(f"✗ Failed to create virtual environment: {e}")
        return False

def get_venv_python():
    """Get the path to the Python executable in the venv"""
    if sys.platform == "win32":
        return VENV_DIR / "Scripts" / "python.exe"
    return VENV_DIR / "bin" / "python"

def setup_venv():
    """Setup virtual environment if not already in one"""
    if is_in_venv():
        return True
    
    if not VENV_DIR.exists():
        print("Virtual environment not found.")
        if not create_venv():
            return False
    
    # Re-run this script using the venv Python
    venv_python = get_venv_python()
    print(f"Switching to virtual environment...")
    print("-" * 50)
    os.execv(str(venv_python), [str(venv_python)] + sys.argv)

def check_dependencies():
    """Check if required packages are installed"""
    try:
        import pygame
        import numpy
        import requests
        print("✓ All dependencies are installed")
        return True
    except ImportError as e:
        print(f"✗ Missing dependency: {e}")
        return False

def install_dependencies():
    """Install required packages"""
    print("Installing dependencies...")
    try:
        subprocess.check_call([
            sys.executable, "-m", "pip", "install", "--upgrade", "pip"
        ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        
        if REQUIREMENTS_FILE.exists():
            subprocess.check_call([
                sys.executable, "-m", "pip", "install", "-r", str(REQUIREMENTS_FILE)
            ])
        else:
            # Fallback: install essential packages
            subprocess.check_call([
                sys.executable, "-m", "pip", "install", "pygame", "numpy", "requests"
            ])
        print("✓ Dependencies installed successfully")
        return True
    except subprocess.CalledProcessError:
        print("✗ Failed to install dependencies")
        return False

def check_server_health(host):
    """Check whether a server responds to /health using only stdlib."""
    try:
        with request.urlopen(f"{host}/health", timeout=1.5) as response:
            payload = json.loads(response.read().decode("utf-8"))
            return True, payload
    except (error.URLError, error.HTTPError, TimeoutError, json.JSONDecodeError, OSError):
        return False, None

def choose_server_host():
    """Ask the user which backend host the visualizer should use."""
    print("\nServer disponibili:")

    statuses = []
    for index, (label, host) in enumerate(KNOWN_SERVER_HOSTS, start=1):
        is_online, payload = check_server_health(host)
        statuses.append({
            "label": label,
            "host": host,
            "online": is_online,
            "payload": payload
        })
        status_label = "online" if is_online else "offline"
        print(f"  {index}. {label}: {host} [{status_label}]")

    print(f"  {len(KNOWN_SERVER_HOSTS) + 1}. Custom host")

    localhost_online = statuses[0]["online"]
    remote_online = len(statuses) > 1 and statuses[1]["online"]

    if not localhost_online and remote_online:
        print(f"Suggerimento: usa {statuses[1]['host']} perché localhost non risponde.")

    choice = input(f"Seleziona il server [1]: ").strip()

    if not choice or choice == '1':
        return KNOWN_SERVER_HOSTS[0][1]

    if choice == '2' and len(KNOWN_SERVER_HOSTS) >= 2:
        return KNOWN_SERVER_HOSTS[1][1]

    if choice == str(len(KNOWN_SERVER_HOSTS) + 1):
        custom_host = input("Inserisci host custom (es. http://host:5055): ").strip().rstrip('/')
        return custom_host or KNOWN_SERVER_HOSTS[0][1]

    typed_host = choice.rstrip('/')
    return typed_host if typed_host.startswith('http://') or typed_host.startswith('https://') else KNOWN_SERVER_HOSTS[0][1]

def main():
    """Main launcher"""
    print("Slither.io Data Visualizer Launcher")
    print("=" * 50)

    # Check if visualizer.py exists
    visualizer_path = Path(__file__).parent / "visualizer.py"
    if not visualizer_path.exists():
        print("✗ visualizer.py not found in the current directory.")
        return 1

    # Setup virtual environment (will restart script if needed)
    setup_venv()

    # At this point we're definitely in a venv
    print(f"Running in virtual environment: {sys.prefix}")

    # Check dependencies
    if not check_dependencies():
        print("\nAttempting to install dependencies...")
        if not install_dependencies():
            print("\nFailed to install dependencies. Please check the error messages above.")
            return 1

    selected_server = choose_server_host()
    os.environ['SLITHER_SERVER_URL'] = selected_server

    # Start the visualizer
    print("\nStarting visualizer...")
    print(f"Using backend server: {selected_server}")
    print("Press Ctrl+C to stop")
    print("-" * 50)

    try:
        # Import and run visualizer
        import runpy
        runpy.run_path(str(visualizer_path), run_name="__main__")
    except KeyboardInterrupt:
        print("\n\nVisualizer stopped by user")
        return 0
    except Exception as e:
        print(f"\n✗ Visualizer error: {e}")
        import traceback
        traceback.print_exc()
        return 1

if __name__ == "__main__":
    sys.exit(main())