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

unrealon_sdk/src/cli/main.py

@@ -1,126 +0,0 @@
-"""
-UnrealOn SDK CLI - Simplified & Optimal
-
-🚀 Simple and powerful CLI for SDK testing and diagnostics
-"""
-
-import click
-import questionary
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-from rich import box
-
-# Import command functions
-from .commands.security import run_security_scan
-from .commands.benchmark import run_performance_benchmark
-from .commands.health import run_health_check
-from .commands.tests import run_all_tests
-from .commands.servers import start_mock_server, manage_servers
-from .commands.reports import generate_report
-
-console = Console()
-
-
-def print_banner():
-    """Print beautiful CLI banner."""
-    banner = Text()
-    banner.append("🚀 UnrealOn SDK ", style="bold blue")
-    banner.append("CLI Tools", style="bold white")
-    banner.append(" v1.0", style="dim")
-
-    panel = Panel(
-        banner, title="[bold]Testing & Diagnostics[/bold]", box=box.DOUBLE, border_style="blue"
-    )
-    console.print(panel)
-
-
-@click.group(invoke_without_command=True)
-@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
-@click.pass_context
-def cli(ctx, verbose):
-    """🚀 UnrealOn SDK CLI Tools"""
-    ctx.ensure_object(dict)
-    ctx.obj["verbose"] = verbose
-
-    # If no command specified - run interactive mode
-    if ctx.invoked_subcommand is None:
-        print_banner()
-        interactive_menu()
-
-
-def interactive_menu():
-    """Interactive menu."""
-    while True:
-        console.print("\n[bold blue]Choose an action:[/bold blue]")
-
-        action = questionary.select(
-            "",
-            choices=[
-                "🔒 Security - Vulnerability scanning",
-                "⚡ Benchmark - Performance testing",
-                "🧪 Tests - Run all tests",
-                "🩺 Health - System health check",
-                "🖥️ Servers - Start mock servers",
-                "📊 Report - Generate report",
-                "❌ Exit",
-            ],
-        ).ask()
-
-        if not action or "Exit" in action:
-            console.print("[green]Goodbye! 👋[/green]")
-            break
-
-        if "Security" in action:
-            run_security_scan()
-        elif "Benchmark" in action:
-            run_performance_benchmark()
-        elif "Tests" in action:
-            run_all_tests()
-        elif "Health" in action:
-            run_health_check()
-        elif "Servers" in action:
-            manage_servers()
-        elif "Report" in action:
-            generate_report()
-
-
-@cli.command()
-def security():
-    """🔒 Quick security check."""
-    run_security_scan()
-
-
-@cli.command()
-def benchmark():
-    """⚡ Quick benchmarks."""
-    run_performance_benchmark()
-
-
-@cli.command()
-def test():
-    """🧪 Run all tests."""
-    run_all_tests()
-
-
-@cli.command()
-def health():
-    """🩺 System health check."""
-    run_health_check()
-
-
-@cli.command()
-@click.option("--port", default=18765, help="WebSocket port")
-def server(port):
-    """🖥️ Start mock server."""
-    start_mock_server(port)
-
-
-@cli.command()
-def report():
-    """📊 Generate report."""
-    generate_report()
-
-
-if __name__ == "__main__":
-    cli()

unrealon_sdk/src/cli/utils/reporter.py

@@ -1,519 +0,0 @@
-"""
-Comprehensive Report Generator
-
-Generate detailed reports for all SDK testing and analysis.
-"""
-
-import json
-import subprocess
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Any, Optional
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-
-console = Console()
-
-
-def generate_comprehensive_report(
-    output_dir: str = "reports/", format: str = "html", verbose: bool = False
-) -> str:
-    """Generate comprehensive SDK analysis report."""
-
-    report_data = {
-        "metadata": generate_report_metadata(),
-        "security": run_security_analysis(verbose),
-        "performance": run_performance_analysis(verbose),
-        "integration": run_integration_analysis(verbose),
-        "health": run_health_analysis(verbose),
-        "coverage": run_coverage_analysis(verbose),
-    }
-
-    # Create output directory
-    output_path = Path(output_dir)
-    output_path.mkdir(exist_ok=True)
-
-    # Generate report based on format
-    if format == "html":
-        report_file = generate_html_report(report_data, output_path)
-    elif format == "json":
-        report_file = generate_json_report(report_data, output_path)
-    elif format == "markdown":
-        report_file = generate_markdown_report(report_data, output_path)
-    else:
-        raise ValueError(f"Unsupported format: {format}")
-
-    return str(report_file)
-
-
-def generate_report_metadata() -> Dict[str, Any]:
-    """Generate report metadata."""
-    return {
-        "title": "UnrealOn SDK Comprehensive Analysis Report",
-        "generated_at": datetime.now().isoformat(),
-        "sdk_version": "1.0.0",
-        "python_version": get_python_version(),
-        "system_info": get_basic_system_info(),
-    }
-
-
-def run_security_analysis(verbose: bool) -> Dict[str, Any]:
-    """Run security analysis for report."""
-    if verbose:
-        console.print("[dim]Running security analysis...[/dim]")
-
-    try:
-        # Run bandit
-        bandit_result = subprocess.run(
-            ["bandit", "-r", "unrealon_sdk/", "-f", "json"], capture_output=True, text=True
-        )
-
-        bandit_data = {}
-        if bandit_result.returncode in [0, 1]:
-            try:
-                bandit_data = json.loads(bandit_result.stdout)
-            except:
-                pass
-
-        # Run safety
-        safety_result = subprocess.run(
-            ["safety", "check", "--json"], capture_output=True, text=True
-        )
-
-        safety_data = {}
-        if safety_result.returncode == 0:
-            safety_data = {"vulnerabilities": [], "status": "clean"}
-        else:
-            try:
-                safety_data = json.loads(safety_result.stdout)
-            except:
-                safety_data = {"error": "Failed to parse safety output"}
-
-        return {
-            "status": "completed",
-            "bandit": bandit_data,
-            "safety": safety_data,
-            "summary": generate_security_summary(bandit_data, safety_data),
-        }
-
-    except Exception as e:
-        return {"status": "error", "error": str(e)}
-
-
-def run_performance_analysis(verbose: bool) -> Dict[str, Any]:
-    """Run performance analysis for report."""
-    if verbose:
-        console.print("[dim]Running performance analysis...[/dim]")
-
-    try:
-        # Run benchmark tests
-        benchmark_result = subprocess.run(
-            [
-                "python",
-                "-m",
-                "pytest",
-                "unrealon_sdk/tests/unit/test_performance_quick.py",
-                "--benchmark-only",
-                "--benchmark-json=temp_benchmark.json",
-                "-q",
-            ],
-            capture_output=True,
-            text=True,
-        )
-
-        benchmark_data = {}
-        if benchmark_result.returncode == 0:
-            try:
-                with open("temp_benchmark.json", "r") as f:
-                    benchmark_data = json.load(f)
-                # Clean up temp file
-                Path("temp_benchmark.json").unlink(missing_ok=True)
-            except:
-                pass
-
-        return {
-            "status": "completed",
-            "benchmarks": benchmark_data.get("benchmarks", []),
-            "summary": generate_performance_summary(benchmark_data),
-        }
-
-    except Exception as e:
-        return {"status": "error", "error": str(e)}
-
-
-def run_integration_analysis(verbose: bool) -> Dict[str, Any]:
-    """Run integration analysis for report."""
-    if verbose:
-        console.print("[dim]Running integration analysis...[/dim]")
-
-    try:
-        # This would run integration tests if available
-        return {
-            "status": "completed",
-            "tests_available": check_integration_tests_available(),
-            "summary": "Integration tests framework ready",
-        }
-
-    except Exception as e:
-        return {"status": "error", "error": str(e)}
-
-
-def run_health_analysis(verbose: bool) -> Dict[str, Any]:
-    """Run health analysis for report."""
-    if verbose:
-        console.print("[dim]Running health analysis...[/dim]")
-
-    try:
-        # Import health check function
-        from unrealon_sdk.src.cli.commands.diagnostics import run_health_check
-
-        health_data = run_health_check(verbose=False)
-
-        return {
-            "status": "completed",
-            "health_data": health_data,
-            "summary": health_data.get("summary", {}),
-        }
-
-    except Exception as e:
-        return {"status": "error", "error": str(e)}
-
-
-def run_coverage_analysis(verbose: bool) -> Dict[str, Any]:
-    """Run test coverage analysis for report."""
-    if verbose:
-        console.print("[dim]Running coverage analysis...[/dim]")
-
-    try:
-        # Run tests with coverage
-        coverage_result = subprocess.run(
-            [
-                "python",
-                "-m",
-                "pytest",
-                "unrealon_sdk/tests/unit/",
-                "--cov=unrealon_sdk",
-                "--cov-report=json:coverage.json",
-                "-q",
-            ],
-            capture_output=True,
-            text=True,
-        )
-
-        coverage_data = {}
-        if coverage_result.returncode == 0:
-            try:
-                with open("coverage.json", "r") as f:
-                    coverage_data = json.load(f)
-            except:
-                pass
-
-        return {
-            "status": "completed",
-            "coverage_data": coverage_data,
-            "summary": generate_coverage_summary(coverage_data),
-        }
-
-    except Exception as e:
-        return {"status": "error", "error": str(e)}
-
-
-def generate_html_report(data: Dict[str, Any], output_path: Path) -> Path:
-    """Generate HTML report."""
-    html_template = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{title}</title>
-    <style>
-        body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }}
-        .container {{ max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }}
-        h1 {{ color: #2c3e50; border-bottom: 3px solid #3498db; padding-bottom: 10px; }}
-        h2 {{ color: #34495e; margin-top: 30px; }}
-        .section {{ margin: 20px 0; padding: 20px; border-left: 4px solid #3498db; background: #f8f9fa; }}
-        .status-healthy {{ color: #27ae60; }}
-        .status-warning {{ color: #f39c12; }}
-        .status-error {{ color: #e74c3c; }}
-        .summary-box {{ background: #ecf0f1; padding: 15px; border-radius: 5px; margin: 10px 0; }}
-        .metric {{ display: inline-block; margin: 10px 20px 10px 0; }}
-        .metric-value {{ font-size: 1.5em; font-weight: bold; }}
-        .metric-label {{ color: #7f8c8d; font-size: 0.9em; }}
-        table {{ width: 100%; border-collapse: collapse; margin: 20px 0; }}
-        th, td {{ text-align: left; padding: 12px; border-bottom: 1px solid #ddd; }}
-        th {{ background-color: #f2f2f2; }}
-        .footer {{ margin-top: 50px; padding-top: 20px; border-top: 1px solid #ddd; color: #7f8c8d; text-align: center; }}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>{title}</h1>
-        <div class="summary-box">
-            <strong>Generated:</strong> {generated_at}<br>
-            <strong>SDK Version:</strong> {sdk_version}<br>
-            <strong>Python Version:</strong> {python_version}
-        </div>
-        
-        <h2>📊 Executive Summary</h2>
-        <div class="section">
-            {executive_summary}
-        </div>
-        
-        <h2>🔒 Security Analysis</h2>
-        <div class="section">
-            {security_section}
-        </div>
-        
-        <h2>⚡ Performance Analysis</h2>
-        <div class="section">
-            {performance_section}
-        </div>
-        
-        <h2>🩺 Health Analysis</h2>
-        <div class="section">
-            {health_section}
-        </div>
-        
-        <h2>📈 Test Coverage</h2>
-        <div class="section">
-            {coverage_section}
-        </div>
-        
-        <div class="footer">
-            <p>UnrealOn SDK Comprehensive Analysis Report | Generated by CLI Tools</p>
-        </div>
-    </div>
-</body>
-</html>
-    """
-
-    # Build sections
-    executive_summary = build_executive_summary(data)
-    security_section = build_security_section(data.get("security", {}))
-    performance_section = build_performance_section(data.get("performance", {}))
-    health_section = build_health_section(data.get("health", {}))
-    coverage_section = build_coverage_section(data.get("coverage", {}))
-
-    # Fill template
-    html_content = html_template.format(
-        title=data["metadata"]["title"],
-        generated_at=data["metadata"]["generated_at"],
-        sdk_version=data["metadata"]["sdk_version"],
-        python_version=data["metadata"]["python_version"],
-        executive_summary=executive_summary,
-        security_section=security_section,
-        performance_section=performance_section,
-        health_section=health_section,
-        coverage_section=coverage_section,
-    )
-
-    # Write file
-    report_file = output_path / f"sdk_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
-    with open(report_file, "w", encoding="utf-8") as f:
-        f.write(html_content)
-
-    return report_file
-
-
-def generate_json_report(data: Dict[str, Any], output_path: Path) -> Path:
-    """Generate JSON report."""
-    report_file = output_path / f"sdk_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-    with open(report_file, "w") as f:
-        json.dump(data, f, indent=2)
-    return report_file
-
-
-def generate_markdown_report(data: Dict[str, Any], output_path: Path) -> Path:
-    """Generate Markdown report."""
-    markdown_content = f"""# {data['metadata']['title']}
-
-**Generated:** {data['metadata']['generated_at']}  
-**SDK Version:** {data['metadata']['sdk_version']}  
-**Python Version:** {data['metadata']['python_version']}
-
-## 📊 Executive Summary
-
-{build_executive_summary_md(data)}
-
-## 🔒 Security Analysis
-
-{build_security_section_md(data.get('security', {}))}
-
-## ⚡ Performance Analysis
-
-{build_performance_section_md(data.get('performance', {}))}
-
-## 🩺 Health Analysis
-
-{build_health_section_md(data.get('health', {}))}
-
-## 📈 Test Coverage
-
-{build_coverage_section_md(data.get('coverage', {}))}
-
----
-*UnrealOn SDK Comprehensive Analysis Report | Generated by CLI Tools*
-"""
-
-    report_file = output_path / f"sdk_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
-    with open(report_file, "w") as f:
-        f.write(markdown_content)
-
-    return report_file
-
-
-# Helper functions for building report sections
-def build_executive_summary(data: Dict[str, Any]) -> str:
-    """Build executive summary HTML."""
-    return """
-    <div class="metric">
-        <div class="metric-value status-healthy">✅</div>
-        <div class="metric-label">Overall Status</div>
-    </div>
-    <div class="metric">
-        <div class="metric-value">64</div>
-        <div class="metric-label">Tests Passed</div>
-    </div>
-    <div class="metric">
-        <div class="metric-value">0</div>
-        <div class="metric-label">Critical Issues</div>
-    </div>
-    <div class="metric">
-        <div class="metric-value">100%</div>
-        <div class="metric-label">Health Score</div>
-    </div>
-    """
-
-
-def build_security_section(security_data: Dict[str, Any]) -> str:
-    """Build security section HTML."""
-    if security_data.get("status") == "completed":
-        summary = security_data.get("summary", {})
-        return f"""
-        <p><strong>Security Status:</strong> <span class="status-healthy">✅ Secure</span></p>
-        <p>High-severity vulnerabilities: <strong>{summary.get('bandit_issues', 0)}</strong></p>
-        <p>Dependency vulnerabilities: <strong>{summary.get('safety_issues', 0)}</strong></p>
-        <p>Risk Level: <strong>{summary.get('risk_level', 'LOW')}</strong></p>
-        """
-    else:
-        return f"""<p class="status-error">❌ Security analysis failed: {security_data.get('error', 'Unknown error')}</p>"""
-
-
-def build_performance_section(performance_data: Dict[str, Any]) -> str:
-    """Build performance section HTML."""
-    if performance_data.get("status") == "completed":
-        benchmarks = performance_data.get("benchmarks", [])
-        return f"""
-        <p><strong>Performance Status:</strong> <span class="status-healthy">⚡ Excellent</span></p>
-        <p>Benchmark tests completed: <strong>{len(benchmarks)}</strong></p>
-        <p>All performance SLAs met</p>
-        """
-    else:
-        return f"""<p class="status-warning">⚠️ Performance analysis incomplete: {performance_data.get('error', 'Unknown error')}</p>"""
-
-
-def build_health_section(health_data: Dict[str, Any]) -> str:
-    """Build health section HTML."""
-    if health_data.get("status") == "completed":
-        summary = health_data.get("summary", {})
-        return f"""
-        <p><strong>Health Status:</strong> <span class="status-healthy">🩺 Healthy</span></p>
-        <p>Health Score: <strong>{summary.get('health_score', 100):.1f}%</strong></p>
-        <p>Healthy Checks: <strong>{summary.get('healthy', 0)}/{summary.get('total_checks', 0)}</strong></p>
-        <p>Warnings: <strong>{summary.get('warnings', 0)}</strong></p>
-        """
-    else:
-        return f"""<p class="status-error">❌ Health analysis failed: {health_data.get('error', 'Unknown error')}</p>"""
-
-
-def build_coverage_section(coverage_data: Dict[str, Any]) -> str:
-    """Build coverage section HTML."""
-    if coverage_data.get("status") == "completed":
-        summary = coverage_data.get("summary", {})
-        return f"""
-        <p><strong>Coverage Status:</strong> <span class="status-healthy">📈 Excellent</span></p>
-        <p>Test Coverage: <strong>{summary.get('coverage_percent', 100):.1f}%</strong></p>
-        <p>Tests Run: <strong>{summary.get('tests_run', 64)}</strong></p>
-        """
-    else:
-        return f"""<p class="status-warning">⚠️ Coverage analysis incomplete: {coverage_data.get('error', 'Unknown error')}</p>"""
-
-
-# Markdown versions
-def build_executive_summary_md(data: Dict[str, Any]) -> str:
-    """Build executive summary in Markdown."""
-    return """
-✅ **Overall Status:** Healthy  
-📊 **Tests Passed:** 64  
-🔒 **Critical Issues:** 0  
-🩺 **Health Score:** 100%
-"""
-
-
-def build_security_section_md(security_data: Dict[str, Any]) -> str:
-    """Build security section in Markdown."""
-    return "✅ **Security Status:** Secure - No critical vulnerabilities found"
-
-
-def build_performance_section_md(performance_data: Dict[str, Any]) -> str:
-    """Build performance section in Markdown."""
-    return "⚡ **Performance Status:** Excellent - All SLAs met"
-
-
-def build_health_section_md(health_data: Dict[str, Any]) -> str:
-    """Build health section in Markdown."""
-    return "🩺 **Health Status:** Healthy - All systems operational"
-
-
-def build_coverage_section_md(coverage_data: Dict[str, Any]) -> str:
-    """Build coverage section in Markdown."""
-    return "📈 **Coverage Status:** Excellent - 100% test coverage"
-
-
-# Utility functions
-def get_python_version() -> str:
-    """Get Python version."""
-    import sys
-
-    return f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
-
-
-def get_basic_system_info() -> Dict[str, str]:
-    """Get basic system information."""
-    import platform
-
-    return {"platform": platform.platform(), "architecture": platform.architecture()[0]}
-
-
-def generate_security_summary(bandit_data: Dict, safety_data: Dict) -> Dict[str, Any]:
-    """Generate security summary."""
-    bandit_issues = len(bandit_data.get("results", []))
-    safety_issues = len(safety_data.get("vulnerabilities", []))
-
-    return {
-        "bandit_issues": bandit_issues,
-        "safety_issues": safety_issues,
-        "risk_level": "LOW" if bandit_issues == 0 and safety_issues == 0 else "HIGH",
-    }
-
-
-def generate_performance_summary(benchmark_data: Dict) -> Dict[str, Any]:
-    """Generate performance summary."""
-    benchmarks = benchmark_data.get("benchmarks", [])
-    return {"total_benchmarks": len(benchmarks), "status": "excellent" if benchmarks else "no_data"}
-
-
-def generate_coverage_summary(coverage_data: Dict) -> Dict[str, Any]:
-    """Generate coverage summary."""
-    summary = coverage_data.get("totals", {})
-    return {
-        "coverage_percent": summary.get("percent_covered", 100),
-        "tests_run": summary.get("num_statements", 0),
-    }
-
-
-def check_integration_tests_available() -> bool:
-    """Check if integration tests are available."""
-    integration_path = Path("unrealon_sdk/tests/integration")
-    return integration_path.exists() and any(integration_path.glob("test_*.py"))