Coding Interview Platform

from hopx_ai import Sandbox
import os
import time
from typing import Dict, Any

class InterviewPlatform:
    def __init__(self, api_key: str):
        self.api_key = api_key
    
    def execute_with_time_limit(self, code: str, time_limit: int, language: str = "python") -> Dict[str, Any]:
        """Execute code with strict time limit"""
        sandbox = None
        start_time = time.time()
        
        try:
            sandbox = Sandbox.create(
                template="code-interpreter",
                api_key=self.api_key,
                timeout_seconds=time_limit + 5
            )
            
            # Execute with timeout
            result = sandbox.run_code(code, language=language, timeout=time_limit)
            
            elapsed = time.time() - start_time
            
            # Check if timeout was exceeded
            if elapsed >= time_limit:
                return {
                    "success": False,
                    "timeout": True,
                    "elapsed_time": elapsed,
                    "time_limit": time_limit,
                    "error": "Time limit exceeded"
                }
            
            return {
                "success": result.success,
                "stdout": result.stdout,
                "stderr": result.stderr,
                "elapsed_time": elapsed,
                "time_limit": time_limit,
                "within_limit": elapsed < time_limit
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "elapsed_time": time.time() - start_time
            }
        finally:
            if sandbox:
                sandbox.kill()

# Usage
platform = InterviewPlatform(api_key=os.getenv("HOPX_API_KEY"))

result = platform.execute_with_time_limit(
    code="print('Hello')",
    time_limit=5  # 5 second limit
)
print(result)

import { Sandbox } from '@hopx-ai/sdk';

class InterviewPlatform {
    constructor(apiKey) {
        this.apiKey = apiKey;
    }
    
    async executeWithTimeLimit(code, timeLimit, language = 'python') {
        let sandbox = null;
        const startTime = Date.now();
        
        try {
            sandbox = await Sandbox.create({
                template: 'code-interpreter',
                apiKey: this.apiKey,
                timeoutSeconds: timeLimit + 5
            });
            
            // Execute with timeout
            const result = await sandbox.runCode(code, {
                language,
                timeout: timeLimit
            });
            
            const elapsed = (Date.now() - startTime) / 1000;
            
            // Check if timeout was exceeded
            if (elapsed >= timeLimit) {
                return {
                    success: false,
                    timeout: true,
                    elapsedTime: elapsed,
                    timeLimit,
                    error: 'Time limit exceeded'
                };
            }
            
            return {
                success: result.success,
                stdout: result.stdout,
                stderr: result.stderr,
                elapsedTime: elapsed,
                timeLimit,
                withinLimit: elapsed < timeLimit
            };
        } catch (error) {
            return {
                success: false,
                error: error.message,
                elapsedTime: (Date.now() - startTime) / 1000
            };
        } finally {
            if (sandbox) {
                await sandbox.kill();
            }
        }
    }
}

// Usage
const platform = new InterviewPlatform(process.env.HOPX_API_KEY);

const result = await platform.executeWithTimeLimit(
    "print('Hello')",
    5  // 5 second limit
);
console.log(result);

class PerformanceMonitor:
    def __init__(self, sandbox: Sandbox):
        self.sandbox = sandbox
    
    def monitor_execution(self, code: str) -> Dict[str, Any]:
        """Monitor code execution performance"""
        import time
        
        start_time = time.time()
        result = self.sandbox.run_code(code, timeout=30)
        elapsed = time.time() - start_time
        
        # Get system metrics
        metrics = self.sandbox.get_metrics_snapshot()
        
        return {
            "execution_time": elapsed,
            "code_execution_time": result.execution_time,
            "memory_usage": getattr(metrics, 'memory_usage_mb', 0) if hasattr(metrics, 'memory_usage_mb') else 0,
            "cpu_usage": getattr(metrics, 'cpu_percent', 0) if hasattr(metrics, 'cpu_percent') else 0,
            "success": result.success
        }

# Usage
sandbox = Sandbox.create(template="code-interpreter", api_key=os.getenv("HOPX_API_KEY"))
monitor = PerformanceMonitor(sandbox)

metrics = monitor.monitor_execution("print('Hello')")
print(f"Execution time: {metrics['execution_time']:.2f}s")
print(f"Memory usage: {metrics['memory_usage']}MB")

sandbox.kill()

class PerformanceMonitor {
    constructor(sandbox) {
        this.sandbox = sandbox;
    }
    
    async monitorExecution(code) {
        const startTime = Date.now();
        const result = await this.sandbox.runCode(code, { timeout: 30 });
        const elapsed = (Date.now() - startTime) / 1000;
        
        // Get system metrics
        const metrics = await this.sandbox.getSystemMetrics();
        
        return {
            executionTime: elapsed,
            codeExecutionTime: result.execution_time,
            memoryUsage: metrics.memory_usage_mb || 0,
            cpuUsage: metrics.cpu_percent || 0,
            success: result.success
        };
    }
}

// Usage
const sandbox = await Sandbox.create({
    template: 'code-interpreter',
    apiKey: process.env.HOPX_API_KEY
});
const monitor = new PerformanceMonitor(sandbox);

const metrics = await monitor.monitorExecution("print('Hello')");
console.log(`Execution time: ${metrics.executionTime.toFixed(2)}s`);
console.log(`Memory usage: ${metrics.memoryUsage}MB`);

await sandbox.kill();