User-Defined Functions Platform

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

class UserFunction:
    def __init__(self, function_id: str, code: str, inputs: List[str], outputs: List[str]):
        self.function_id = function_id
        self.code = code
        self.inputs = inputs
        self.outputs = outputs

class UserFunctionPlatform:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.functions = {}
        self.sandbox = None
    
    def initialize(self):
        """Initialize platform"""
        self.sandbox = Sandbox.create(
            template="code-interpreter",
            api_key=self.api_key,
            timeout_seconds=3600
        )
    
    def register_function(self, function: UserFunction):
        """Register user function"""
        self.functions[function.function_id] = function
    
    def execute_function(self, function_id: str, inputs: Dict[str, Any]) -> Dict[str, Any]:
        """Execute user function with inputs"""
        if function_id not in self.functions:
            return {
                "success": False,
                "error": f"Function {function_id} not found"
            }
        
        function = self.functions[function_id]
        
        try:
            # Prepare function code with inputs
            import json
            function_code = f"""
import json

# Inputs
inputs = {json.dumps(inputs)}

# User function
{function.code}
"""
            
            result = self.sandbox.run_code(function_code, timeout=30)
            
            return {
                "success": result.success,
                "output": result.stdout,
                "error": result.stderr if not result.success else None
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e)
            }
    
    def cleanup(self):
        """Clean up platform resources"""
        if self.sandbox:
            self.sandbox.kill()
            self.sandbox = None

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

# Register function
platform.register_function(UserFunction(
    function_id="add_numbers",
    code="result = inputs['a'] + inputs['b']\nprint(result)",
    inputs=["a", "b"],
    outputs=["result"]
))

# Execute
result = platform.execute_function("add_numbers", {"a": 5, "b": 3})
print(result)

platform.cleanup()

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

class UserFunction {
    constructor(functionId, code, inputs, outputs) {
        this.functionId = functionId;
        this.code = code;
        this.inputs = inputs;
        this.outputs = outputs;
    }
}

class UserFunctionPlatform {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.functions = {};
        this.sandbox = null;
    }
    
    async initialize() {
        this.sandbox = await Sandbox.create({
            template: 'code-interpreter',
            apiKey: this.apiKey,
            timeoutSeconds: 3600
        });
    }
    
    registerFunction(func) {
        this.functions[func.functionId] = func;
    }
    
    async executeFunction(functionId, inputs) {
        if (!this.functions[functionId]) {
            return {
                success: false,
                error: `Function ${functionId} not found`
            };
        }
        
        const func = this.functions[functionId];
        
        try {
            // Prepare function code with inputs
            const functionCode = `
// Inputs
const inputs = ${JSON.stringify(inputs)};

// User function
${func.code}
`;
            
            const result = await this.sandbox.runCode(functionCode, { timeout: 30 });
            
            return {
                success: result.success,
                output: result.stdout,
                error: !result.success ? result.stderr : null
            };
        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    }
    
    async cleanup() {
        if (this.sandbox) {
            await this.sandbox.kill();
            this.sandbox = null;
        }
    }
}

// Usage
const platform = new UserFunctionPlatform(process.env.HOPX_API_KEY);
await platform.initialize();

// Register function
platform.registerFunction(new UserFunction(
    'add_numbers',
    "const result = inputs.a + inputs.b;\nconsole.log(result);",
    ['a', 'b'],
    ['result']
));

// Execute
const result = await platform.executeFunction('add_numbers', { a: 5, b: 3 });
console.log(result);

await platform.cleanup();