unrealon 1.0.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

unrealon_sdk/src/cli/commands/server.py

@@ -1,483 +0,0 @@
-"""
-Mock Server Management CLI Commands
-
-Start, stop, and manage development mock servers.
-"""
-
-import click
-import questionary
-import asyncio
-import signal
-import sys
-from pathlib import Path
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-from typing import Dict, List, Any, Optional
-
-console = Console()
-
-
-@click.group()
-def server_cli():
-    """🖥️ Mock server management for development."""
-    pass
-
-
-@server_cli.command()
-@click.option('--websocket-port', default=18765, help='WebSocket server port')
-@click.option('--http-port', default=18080, help='HTTP server port')
-@click.option('--latency', default=50, help='Simulated latency in ms')
-@click.option('--error-rate', default=0.05, help='Error simulation rate (0-1)')
-@click.option('--background', '-d', is_flag=True, help='Run in background')
-def start(websocket_port, http_port, latency, error_rate, background):
-    """🚀 Start development mock servers."""
-    console.print("[bold blue]🖥️ Starting Development Mock Servers[/bold blue]")
-    
-    if background:
-        console.print("[yellow]Starting servers in background mode...[/yellow]")
-        start_servers_background(websocket_port, http_port, latency, error_rate)
-    else:
-        console.print("[yellow]Starting servers in foreground mode (Press Ctrl+C to stop)...[/yellow]")
-        start_servers_foreground(websocket_port, http_port, latency, error_rate)
-
-
-@server_cli.command()
-@click.option('--all', 'stop_all', is_flag=True, help='Stop all running servers')
-@click.option('--websocket', is_flag=True, help='Stop WebSocket server only')
-@click.option('--http', is_flag=True, help='Stop HTTP server only')
-def stop(stop_all, websocket, http):
-    """🛑 Stop mock servers."""
-    console.print("[bold blue]🛑 Stopping Mock Servers[/bold blue]")
-    
-    if stop_all:
-        stop_all_servers()
-    elif websocket:
-        stop_websocket_server()
-    elif http:
-        stop_http_server()
-    else:
-        # Interactive selection
-        servers_to_stop = questionary.checkbox(
-            "Select servers to stop:",
-            choices=["WebSocket Server", "HTTP Server"]
-        ).ask()
-        
-        for server in servers_to_stop:
-            if "WebSocket" in server:
-                stop_websocket_server()
-            elif "HTTP" in server:
-                stop_http_server()
-
-
-@server_cli.command()
-def status():
-    """📊 Show server status and information."""
-    console.print("[bold blue]📊 Mock Server Status[/bold blue]")
-    
-    server_status = get_server_status()
-    display_server_status(server_status)
-
-
-@server_cli.command()
-@click.option('--server', default='both',
-              type=click.Choice(['websocket', 'http', 'both']),
-              help='Server to restart')
-def restart(server):
-    """🔄 Restart mock servers."""
-    console.print(f"[bold blue]🔄 Restarting {server.title()} Server(s)[/bold blue]")
-    
-    if server in ['websocket', 'both']:
-        console.print("[yellow]Restarting WebSocket server...[/yellow]")
-        restart_websocket_server()
-    
-    if server in ['http', 'both']:
-        console.print("[yellow]Restarting HTTP server...[/yellow]")
-        restart_http_server()
-
-
-@server_cli.command()
-@click.option('--config-file', help='Server configuration file')
-def configure(config_file):
-    """⚙️ Configure mock server settings."""
-    console.print("[bold blue]⚙️ Mock Server Configuration[/bold blue]")
-    
-    if config_file and Path(config_file).exists():
-        load_server_config(config_file)
-    else:
-        create_interactive_config()
-
-
-@server_cli.command()
-def interactive():
-    """🎯 Interactive server management."""
-    console.print("[bold blue]🖥️ Interactive Server Management[/bold blue]")
-    
-    action = questionary.select(
-        "What would you like to do?",
-        choices=[
-            "🚀 Start development servers",
-            "🛑 Stop running servers",
-            "📊 Check server status", 
-            "🔄 Restart servers",
-            "⚙️ Configure server settings",
-            "📋 View server logs",
-            "🔧 Server troubleshooting"
-        ]
-    ).ask()
-    
-    if "Start development" in action:
-        start_servers_interactive()
-    elif "Stop running" in action:
-        stop_servers_interactive()
-    elif "Check server status" in action:
-        console.print("[yellow]📊 Checking server status...[/yellow]")
-        server_status = get_server_status()
-        display_server_status(server_status)
-    elif "Restart servers" in action:
-        restart_servers_interactive()
-    elif "Configure server" in action:
-        configure_servers_interactive()
-    elif "View server logs" in action:
-        view_server_logs()
-    elif "Server troubleshooting" in action:
-        troubleshoot_servers()
-
-
-def start_servers_foreground(ws_port: int, http_port: int, latency: int, error_rate: float):
-    """Start servers in foreground mode."""
-    console.print(f"[green]🔗 WebSocket Server: ws://localhost:{ws_port}[/green]")
-    console.print(f"[green]🌐 HTTP Server: http://localhost:{http_port}[/green]")
-    console.print(f"[dim]Latency: {latency}ms | Error Rate: {error_rate*100:.1f}%[/dim]")
-    
-    # Setup signal handlers for graceful shutdown
-    def signal_handler(sig, frame):
-        console.print("\n[yellow]Shutting down servers...[/yellow]")
-        # Stop servers gracefully
-        stop_all_servers()
-        console.print("[green]Servers stopped successfully[/green]")
-        sys.exit(0)
-    
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
-    
-    try:
-        # This would start the actual async servers
-        console.print("[green]✅ Servers started successfully[/green]")
-        console.print("[dim]Press Ctrl+C to stop servers[/dim]")
-        
-        # Keep running
-        asyncio.run(run_servers_forever(ws_port, http_port, latency, error_rate))
-        
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Stopping servers...[/yellow]")
-    except Exception as e:
-        console.print(f"[red]❌ Server error: {e}[/red]")
-    finally:
-        stop_all_servers()
-
-
-def start_servers_background(ws_port: int, http_port: int, latency: int, error_rate: float):
-    """Start servers in background mode."""
-    # This would start servers as daemon processes
-    console.print(f"[green]✅ Servers started in background[/green]")
-    console.print(f"[green]🔗 WebSocket: ws://localhost:{ws_port}[/green]")
-    console.print(f"[green]🌐 HTTP: http://localhost:{http_port}[/green]")
-    
-    # Save server info for management
-    save_server_info({
-        'websocket': {'port': ws_port, 'status': 'running'},
-        'http': {'port': http_port, 'status': 'running'},
-        'config': {'latency': latency, 'error_rate': error_rate}
-    })
-
-
-async def run_servers_forever(ws_port: int, http_port: int, latency: int, error_rate: float):
-    """Run servers indefinitely."""
-    # This would run the actual async servers
-    try:
-        # Import and start actual mock servers
-        from unrealon_sdk.src.tests.integration.mock_servers.websocket_server import (
-            MockWebSocketServer, MockServerConfig
-        )
-        from unrealon_sdk.src.tests.integration.mock_servers.http_server import (
-            MockHTTPServer, MockHTTPConfig
-        )
-        
-        # Create server configurations
-        ws_config = MockServerConfig(
-            host="localhost",
-            port=ws_port,
-            simulate_latency_ms=latency,
-            simulate_errors=True,
-            error_rate=error_rate
-        )
-        
-        http_config = MockHTTPConfig(
-            host="localhost", 
-            port=http_port,
-            simulate_latency_ms=latency,
-            simulate_errors=True,
-            error_rate=error_rate
-        )
-        
-        # Start servers
-        ws_server = MockWebSocketServer(ws_config)
-        http_server = MockHTTPServer(http_config)
-        
-        await ws_server.start_server()
-        await http_server.start_server()
-        
-        console.print("[green]✅ Mock servers running successfully[/green]")
-        
-        # Keep running
-        while True:
-            await asyncio.sleep(1)
-            
-    except Exception as e:
-        console.print(f"[red]❌ Server error: {e}[/red]")
-    finally:
-        try:
-            await ws_server.stop_server()
-            await http_server.stop_server()
-        except:
-            pass
-
-
-def stop_all_servers():
-    """Stop all running mock servers."""
-    console.print("[yellow]Stopping all servers...[/yellow]")
-    # Implementation would stop actual servers
-    console.print("[green]✅ All servers stopped[/green]")
-
-
-def stop_websocket_server():
-    """Stop WebSocket server."""
-    console.print("[yellow]Stopping WebSocket server...[/yellow]")
-    console.print("[green]✅ WebSocket server stopped[/green]")
-
-
-def stop_http_server():
-    """Stop HTTP server."""
-    console.print("[yellow]Stopping HTTP server...[/yellow]")
-    console.print("[green]✅ HTTP server stopped[/green]")
-
-
-def restart_websocket_server():
-    """Restart WebSocket server."""
-    stop_websocket_server()
-    # Wait a moment
-    import time
-    time.sleep(1)
-    console.print("[green]✅ WebSocket server restarted[/green]")
-
-
-def restart_http_server():
-    """Restart HTTP server."""
-    stop_http_server()
-    # Wait a moment
-    import time
-    time.sleep(1)
-    console.print("[green]✅ HTTP server restarted[/green]")
-
-
-def get_server_status() -> Dict[str, Any]:
-    """Get current server status."""
-    # This would check actual server status
-    return {
-        'websocket': {
-            'status': 'running',
-            'port': 18765,
-            'connections': 3,
-            'uptime': '2h 15m',
-            'requests_handled': 1247
-        },
-        'http': {
-            'status': 'running',
-            'port': 18080,
-            'connections': 5,
-            'uptime': '2h 15m',
-            'requests_handled': 892
-        },
-        'system': {
-            'memory_usage': '45.2 MB',
-            'cpu_usage': '2.1%',
-            'total_connections': 8
-        }
-    }
-
-
-def display_server_status(status: Dict[str, Any]):
-    """Display server status information."""
-    # Status overview panel
-    overview_text = f"""
-[bold]Mock Servers Status[/bold]
-
-🔗 WebSocket: {status['websocket']['status']} (Port {status['websocket']['port']})
-🌐 HTTP: {status['http']['status']} (Port {status['http']['port']})
-
-📊 Total Connections: {status['system']['total_connections']}
-💾 Memory Usage: {status['system']['memory_usage']}
-⚡ CPU Usage: {status['system']['cpu_usage']}
-"""
-    
-    console.print(Panel(overview_text, title="Server Status", border_style="green"))
-    
-    # Detailed status table
-    table = Table(title="Detailed Server Information")
-    table.add_column("Server", style="cyan")
-    table.add_column("Status", style="green")
-    table.add_column("Port", justify="right", style="blue")
-    table.add_column("Connections", justify="right", style="yellow")
-    table.add_column("Uptime", style="magenta")
-    table.add_column("Requests", justify="right", style="white")
-    
-    for server_type, server_info in status.items():
-        if server_type != 'system':
-            table.add_row(
-                server_type.title(),
-                f"✅ {server_info['status']}",
-                str(server_info['port']),
-                str(server_info['connections']),
-                server_info['uptime'],
-                str(server_info['requests_handled'])
-            )
-    
-    console.print(table)
-
-
-def save_server_info(info: Dict[str, Any]):
-    """Save server information for management."""
-    server_info_file = Path.home() / '.unrealon_servers.json'
-    import json
-    with open(server_info_file, 'w') as f:
-        json.dump(info, f, indent=2)
-
-
-def load_server_config(config_file: str):
-    """Load server configuration from file."""
-    console.print(f"[yellow]Loading configuration from {config_file}...[/yellow]")
-    # Implementation to load config
-
-
-def create_interactive_config():
-    """Create server configuration interactively."""
-    console.print("[yellow]⚙️ Creating server configuration...[/yellow]")
-    
-    ws_port = questionary.text("WebSocket port:", default="18765").ask()
-    http_port = questionary.text("HTTP port:", default="18080").ask()
-    latency = questionary.text("Simulated latency (ms):", default="50").ask()
-    error_rate = questionary.text("Error rate (0-1):", default="0.05").ask()
-    
-    config = {
-        'websocket_port': int(ws_port),
-        'http_port': int(http_port),
-        'latency': int(latency),
-        'error_rate': float(error_rate)
-    }
-    
-    console.print("[green]✅ Configuration created[/green]")
-    console.print(f"[dim]Config: {config}[/dim]")
-
-
-def start_servers_interactive():
-    """Start servers interactively."""
-    ws_port = questionary.text("WebSocket port:", default="18765").ask()
-    http_port = questionary.text("HTTP port:", default="18080").ask()
-    latency = questionary.text("Simulated latency (ms):", default="50").ask()
-    error_rate = questionary.text("Error rate (0-1):", default="0.05").ask()
-    background = questionary.confirm("Run in background?").ask()
-    
-    if background:
-        start_servers_background(int(ws_port), int(http_port), int(latency), float(error_rate))
-    else:
-        start_servers_foreground(int(ws_port), int(http_port), int(latency), float(error_rate))
-
-
-def stop_servers_interactive():
-    """Stop servers interactively."""
-    servers_to_stop = questionary.checkbox(
-        "Select servers to stop:",
-        choices=["WebSocket Server (Port 18765)", "HTTP Server (Port 18080)"]
-    ).ask()
-    
-    for server in servers_to_stop:
-        if "WebSocket" in server:
-            stop_websocket_server()
-        elif "HTTP" in server:
-            stop_http_server()
-
-
-def restart_servers_interactive():
-    """Restart servers interactively."""
-    server = questionary.select(
-        "Which server to restart?",
-        choices=["WebSocket Server", "HTTP Server", "Both Servers"]
-    ).ask()
-    
-    if "WebSocket" in server:
-        restart_websocket_server()
-    elif "HTTP" in server:
-        restart_http_server()
-    elif "Both" in server:
-        restart_websocket_server()
-        restart_http_server()
-
-
-def configure_servers_interactive():
-    """Configure servers interactively."""
-    console.print("[yellow]⚙️ Interactive server configuration...[/yellow]")
-    create_interactive_config()
-
-
-def view_server_logs():
-    """View server logs."""
-    console.print("[yellow]📋 Viewing server logs...[/yellow]")
-    
-    # Mock log entries
-    logs = [
-        "[2025-08-11 01:00:15] WebSocket server started on port 18765",
-        "[2025-08-11 01:00:16] HTTP server started on port 18080", 
-        "[2025-08-11 01:00:20] WebSocket client connected from 127.0.0.1",
-        "[2025-08-11 01:00:25] HTTP request: GET /api/v1/health",
-        "[2025-08-11 01:00:30] WebSocket message received: register_parser"
-    ]
-    
-    for log in logs:
-        console.print(f"[dim]{log}[/dim]")
-
-
-def troubleshoot_servers():
-    """Troubleshoot server issues."""
-    console.print("[yellow]🔧 Server troubleshooting...[/yellow]")
-    
-    issue_type = questionary.select(
-        "What issue are you experiencing?",
-        choices=[
-            "Server won't start",
-            "Connection refused",
-            "High latency",
-            "Memory issues",
-            "Port conflicts"
-        ]
-    ).ask()
-    
-    console.print(f"[yellow]Diagnosing: {issue_type}[/yellow]")
-    
-    # Provide troubleshooting steps based on issue
-    if "won't start" in issue_type:
-        console.print("[dim]• Check if ports are already in use[/dim]")
-        console.print("[dim]• Verify Python dependencies are installed[/dim]")
-        console.print("[dim]• Check system permissions[/dim]")
-    elif "Connection refused" in issue_type:
-        console.print("[dim]• Verify server is running: unrealon-cli server status[/dim]")
-        console.print("[dim]• Check firewall settings[/dim]")
-        console.print("[dim]• Confirm correct port numbers[/dim]")
-    elif "High latency" in issue_type:
-        console.print("[dim]• Check latency configuration[/dim]")
-        console.print("[dim]• Monitor system resources[/dim]")
-        console.print("[dim]• Verify network connectivity[/dim]")
-
-
-if __name__ == '__main__':
-    server_cli()

unrealon_sdk/src/cli/commands/servers.py

@@ -1,56 +0,0 @@
-"""
-Server Management Commands
-
-Mock server management for UnrealOn SDK.
-"""
-
-import questionary
-from rich.console import Console
-from typing import Dict, Any
-
-console = Console()
-
-
-def start_mock_server(port: int) -> Dict[str, Any]:
-    """Start WebSocket server."""
-    console.print(f"[green]🚀 Starting WebSocket server on port {port}...[/green]")
-    console.print(f"[cyan]URL: ws://localhost:{port}[/cyan]")
-    console.print("[dim]Press Ctrl+C to stop[/dim]")
-    
-    try:
-        # Here would be real server startup
-        import time
-        while True:
-            time.sleep(1)
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Server stopped[/yellow]")
-        return {'status': 'stopped'}
-
-
-def manage_servers() -> Dict[str, Any]:
-    """Server management menu."""
-    console.print("[bold blue]🖥️ Mock server management...[/bold blue]")
-    
-    action = questionary.select(
-        "Choose action:",
-        choices=[
-            "🚀 Start WebSocket server",
-            "🌐 Start HTTP server", 
-            "🛑 Stop servers",
-            "📊 Server status"
-        ]
-    ).ask()
-    
-    if "WebSocket" in action:
-        port = questionary.text("WebSocket port:", default="18765").ask()
-        return start_mock_server(int(port))
-    elif "HTTP" in action:
-        port = questionary.text("HTTP port:", default="18080").ask()
-        console.print(f"[green]HTTP server on port {port} (in development)[/green]")
-        return {'status': 'development', 'port': port}
-    elif "Stop" in action:
-        console.print("[yellow]Stopping servers...[/yellow]")
-        return {'status': 'stopped'}
-    elif "status" in action:
-        console.print("[green]All servers running normally[/green]")
-        return {'status': 'running'}

unrealon_sdk/src/cli/commands/tests.py

@@ -1,55 +0,0 @@
-"""
-Test Runner Commands
-
-Test execution for UnrealOn SDK.
-"""
-
-import subprocess
-from rich.console import Console
-from typing import Dict, Any
-
-console = Console()
-
-
-def run_all_tests() -> Dict[str, Any]:
-    """Run all tests."""
-    console.print("[bold blue]🧪 Running all tests...[/bold blue]")
-    
-    with console.status("[bold green]Testing..."):
-        try:
-            result = subprocess.run([
-                'python', '-m', 'pytest',
-                'unrealon_sdk/tests/unit/',
-                '--tb=short', '-v'
-            ], capture_output=True, text=True)
-            
-            # Parse results
-            lines = result.stdout.split('\n')
-            passed = failed = 0
-            
-            for line in lines:
-                if 'passed' in line and 'failed' in line:
-                    # Extract statistics
-                    parts = line.split()
-                    for i, part in enumerate(parts):
-                        if 'passed' in part:
-                            try:
-                                passed = int(parts[i-1])
-                            except:
-                                pass
-                        if 'failed' in part:
-                            try:
-                                failed = int(parts[i-1])
-                            except:
-                                pass
-            
-            if failed == 0:
-                console.print(f"[green]✅ All {passed} tests passed successfully[/green]")
-                return {'status': 'passed', 'passed': passed, 'failed': 0}
-            else:
-                console.print(f"[red]❌ {failed} tests failed out of {passed + failed}[/red]")
-                return {'status': 'failed', 'passed': passed, 'failed': failed}
-                
-        except Exception as e:
-            console.print(f"[red]Error: {e}[/red]")
-            return {'status': 'error', 'message': str(e)}