Buckets:

download
raw
28 kB
"""
Code execution with static validation and multi-language support.
This module runs code in a local subprocess (``LocalSandbox``) or a Docker
container (``DockerSandbox``) with resource limits, static code validation, and
output capture.
Isolation levels differ and callers should pick with that in mind:
- ``DockerSandbox`` confines the filesystem and network in a container.
- ``LocalSandbox`` runs code in a subprocess and screens it with an AST/regex
validator (``effgen.execution.validators.CodeValidator``). That validator is a
static check, not an operating-system boundary: code that builds forbidden
names or imports at run time can defeat it, so ``LocalSandbox`` does not
isolate the host filesystem, environment, or process table.
For a model-facing tool with the project's hardened isolation, use the
registered ``code_executor`` tool (``effgen.tools.builtin.code_executor``),
which dispatches to ``effgen.security.sandbox`` (Docker when available, a
subprocess fallback that confines network and ``/tmp``).
"""
from __future__ import annotations
import logging
import os
import tempfile
import time
import traceback
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from enum import Enum
from typing import Any
from .validators import CodeValidator, ValidationResult
logger = logging.getLogger(__name__)
class ExecutionStatus(Enum):
"""Status of code execution."""
SUCCESS = "success"
ERROR = "error"
TIMEOUT = "timeout"
VALIDATION_FAILED = "validation_failed"
RESOURCE_LIMIT_EXCEEDED = "resource_limit_exceeded"
@dataclass
class ExecutionResult:
"""Result of code execution."""
status: ExecutionStatus
output: str = ""
error: str = ""
return_value: Any = None
execution_time: float = 0.0
memory_used: int | None = None
exit_code: int = 0
validation_result: ValidationResult | None = None
metadata: dict[str, Any] = field(default_factory=dict)
@property
def success(self) -> bool:
"""Check if execution was successful."""
return self.status == ExecutionStatus.SUCCESS
def to_dict(self) -> dict[str, Any]:
"""Convert result to dictionary."""
return {
"status": self.status.value,
"output": self.output,
"error": self.error,
"return_value": str(self.return_value) if self.return_value is not None else None,
"execution_time": self.execution_time,
"memory_used": self.memory_used,
"exit_code": self.exit_code,
"metadata": self.metadata
}
class SandboxConfig:
"""Configuration for sandbox execution."""
def __init__(self,
timeout: int = 30,
memory_limit: str = "512M",
cpu_limit: float | None = None,
allow_network: bool = False,
allow_file_ops: bool = False,
max_output_size: int = 1024 * 1024, # 1MB
working_dir: str | None = None,
env_vars: dict[str, str] | None = None,
custom_allow_imports: set | None = None) -> None:
"""
Initialize sandbox configuration.
Args:
timeout: Maximum execution time in seconds
memory_limit: Maximum memory (e.g., "512M", "1G")
cpu_limit: CPU limit as fraction (e.g., 0.5 = 50% of one CPU)
allow_network: Whether to allow network access
allow_file_ops: Whether to allow file operations
max_output_size: Maximum output size in bytes
working_dir: Working directory for execution
env_vars: Environment variables to set
custom_allow_imports: Custom set of allowed Python imports
"""
self.timeout = timeout
self.memory_limit = memory_limit
self.cpu_limit = cpu_limit
self.allow_network = allow_network
self.allow_file_ops = allow_file_ops
self.max_output_size = max_output_size
self.working_dir = working_dir or tempfile.gettempdir()
self.env_vars = env_vars or {}
self.custom_allow_imports = custom_allow_imports
def parse_memory_limit(self) -> int:
"""
Parse memory limit string to bytes.
Returns:
Memory limit in bytes
"""
limit = self.memory_limit.upper()
if limit.endswith('K'):
return int(limit[:-1]) * 1024
elif limit.endswith('M'):
return int(limit[:-1]) * 1024 * 1024
elif limit.endswith('G'):
return int(limit[:-1]) * 1024 * 1024 * 1024
else:
return int(limit)
class BaseSandbox(ABC):
"""
Abstract base class for code execution sandboxes.
All sandbox implementations must inherit from this class
and implement the execute method.
"""
def __init__(self, config: SandboxConfig | None = None) -> None:
"""
Initialize sandbox.
Args:
config: Sandbox configuration
"""
self.config = config or SandboxConfig()
self.validator = CodeValidator(
allow_network=self.config.allow_network,
allow_file_ops=self.config.allow_file_ops,
custom_allow_imports=self.config.custom_allow_imports
)
@abstractmethod
def execute(self, code: str, language: str) -> ExecutionResult:
"""
Execute code in the sandbox.
Args:
code: Code to execute
language: Programming language
Returns:
ExecutionResult with output and status
"""
pass
def validate_code(self, code: str, language: str) -> ValidationResult:
"""
Validate code before execution.
Args:
code: Code to validate
language: Programming language
Returns:
ValidationResult with any issues found
"""
return self.validator.validate(code, language)
def _prepare_environment(self) -> dict[str, str]:
"""
Prepare environment variables for execution.
Returns:
Dictionary of environment variables
"""
env = os.environ.copy()
env.update(self.config.env_vars)
# Add security-related environment variables
env['PYTHONDONTWRITEBYTECODE'] = '1'
env['PYTHONUNBUFFERED'] = '1'
return env
def _truncate_output(self, output: str) -> str:
"""
Truncate output if it exceeds maximum size.
Args:
output: Output string
Returns:
Truncated output if necessary
"""
if len(output) > self.config.max_output_size:
truncated_size = self.config.max_output_size - 100
return (output[:truncated_size] +
f"\n... [Output truncated at {self.config.max_output_size} bytes]")
return output
class LocalSandbox(BaseSandbox):
"""Runs code in a local subprocess, screened by a static validator.
The subprocess carries resource limits, and code is checked by the
AST/regex ``CodeValidator`` before it runs. That validator is a static
check, not an operating-system boundary: it does not isolate the host
filesystem, environment, or process table. Use ``DockerSandbox`` or the
``code_executor`` tool (``effgen.security.sandbox``) when isolation from
untrusted code matters.
"""
def execute(self, code: str, language: str) -> ExecutionResult:
"""
Execute code in local subprocess.
Args:
code: Code to execute
language: Programming language
Returns:
ExecutionResult with output and status
"""
start_time = time.time()
# Validate code first
validation_result = self.validate_code(code, language)
if not validation_result.is_safe:
return ExecutionResult(
status=ExecutionStatus.VALIDATION_FAILED,
error=f"Code validation failed: {validation_result.issues}",
validation_result=validation_result,
execution_time=time.time() - start_time
)
# Execute based on language
try:
if language.lower() in {'python', 'py'}:
result = self._execute_python(code)
elif language.lower() in {'javascript', 'js', 'node'}:
result = self._execute_javascript(code)
elif language.lower() in {'bash', 'sh', 'shell'}:
result = self._execute_bash(code)
else:
return ExecutionResult(
status=ExecutionStatus.ERROR,
error=f"Unsupported language: {language}",
execution_time=time.time() - start_time
)
result.execution_time = time.time() - start_time
result.validation_result = validation_result
return result
except TimeoutError:
return ExecutionResult(
status=ExecutionStatus.TIMEOUT,
error=f"Execution timed out after {self.config.timeout} seconds",
execution_time=time.time() - start_time
)
except Exception as e:
return ExecutionResult(
status=ExecutionStatus.ERROR,
error=f"Execution error: {str(e)}\n{traceback.format_exc()}",
execution_time=time.time() - start_time
)
def _execute_python(self, code: str) -> ExecutionResult:
"""
Execute Python code.
Args:
code: Python code to execute
Returns:
ExecutionResult
"""
import subprocess
import sys
# Create temporary file for code
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
f.write(code)
temp_file = f.name
try:
# Execute with subprocess
env = self._prepare_environment()
process = subprocess.Popen(
[sys.executable, temp_file],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env,
cwd=self.config.working_dir
)
try:
stdout, stderr = process.communicate(timeout=self.config.timeout)
output = stdout.decode('utf-8', errors='replace')
error = stderr.decode('utf-8', errors='replace')
output = self._truncate_output(output)
error = self._truncate_output(error)
status = (ExecutionStatus.SUCCESS if process.returncode == 0
else ExecutionStatus.ERROR)
return ExecutionResult(
status=status,
output=output,
error=error,
exit_code=process.returncode
)
except subprocess.TimeoutExpired:
process.kill()
raise TimeoutError()
finally:
# Clean up temporary file
try:
os.unlink(temp_file)
except Exception as e:
logger.debug(f"Failed to clean up temp file: {e}")
def _execute_javascript(self, code: str) -> ExecutionResult:
"""
Execute JavaScript code using Node.js.
Args:
code: JavaScript code to execute
Returns:
ExecutionResult
"""
import shutil
import subprocess
# Check if Node.js is available
if not shutil.which('node'):
return ExecutionResult(
status=ExecutionStatus.ERROR,
error="Node.js is not installed or not in PATH"
)
# Create temporary file for code
with tempfile.NamedTemporaryFile(mode='w', suffix='.js', delete=False) as f:
f.write(code)
temp_file = f.name
try:
env = self._prepare_environment()
process = subprocess.Popen(
['node', temp_file],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env,
cwd=self.config.working_dir
)
try:
stdout, stderr = process.communicate(timeout=self.config.timeout)
output = stdout.decode('utf-8', errors='replace')
error = stderr.decode('utf-8', errors='replace')
output = self._truncate_output(output)
error = self._truncate_output(error)
status = (ExecutionStatus.SUCCESS if process.returncode == 0
else ExecutionStatus.ERROR)
return ExecutionResult(
status=status,
output=output,
error=error,
exit_code=process.returncode
)
except subprocess.TimeoutExpired:
process.kill()
raise TimeoutError()
finally:
try:
os.unlink(temp_file)
except Exception as e:
logger.debug(f"Failed to clean up temp file: {e}")
def _execute_bash(self, code: str) -> ExecutionResult:
"""
Execute Bash script.
Args:
code: Bash script to execute
Returns:
ExecutionResult
"""
import subprocess
try:
env = self._prepare_environment()
process = subprocess.Popen(
['bash', '-c', code],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env,
cwd=self.config.working_dir
)
try:
stdout, stderr = process.communicate(timeout=self.config.timeout)
output = stdout.decode('utf-8', errors='replace')
error = stderr.decode('utf-8', errors='replace')
output = self._truncate_output(output)
error = self._truncate_output(error)
status = (ExecutionStatus.SUCCESS if process.returncode == 0
else ExecutionStatus.ERROR)
return ExecutionResult(
status=status,
output=output,
error=error,
exit_code=process.returncode
)
except subprocess.TimeoutExpired:
process.kill()
raise TimeoutError()
except Exception as e:
return ExecutionResult(
status=ExecutionStatus.ERROR,
error=f"Bash execution error: {str(e)}"
)
class CodeExecutor:
"""Selects a backend (``LocalSandbox`` or ``DockerSandbox``) and runs code.
This is a convenience wrapper around the backends in this module. The
``"local"`` backend (the default) relies on the AST/regex
``CodeValidator`` — a static check, not host isolation (see the module
docstring). To run code an untrusted model produced with the project's
hardened isolation, use the registered ``code_executor`` tool
(``effgen.tools.builtin.code_executor``) instead, which dispatches to
``effgen.security.sandbox``.
"""
def __init__(self,
sandbox_type: str = "local",
config: SandboxConfig | None = None) -> None:
"""
Initialize code executor.
Args:
sandbox_type: Type of sandbox ("local" or "docker")
config: Sandbox configuration
Raises:
ValueError: If sandbox type is not supported
"""
self.sandbox_type = sandbox_type
self.config = config or SandboxConfig()
# Create sandbox instance
if sandbox_type == "local":
self.sandbox = LocalSandbox(self.config)
elif sandbox_type == "docker":
# Import here to avoid circular dependency
from .docker_sandbox import DockerSandbox
self.sandbox = DockerSandbox(self.config)
else:
raise ValueError(f"Unsupported sandbox type: {sandbox_type}")
def execute(self,
code: str,
language: str = "python",
timeout: int | None = None,
memory_limit: str | None = None,
allow_network: bool | None = None) -> ExecutionResult:
"""
Execute code in sandbox.
Args:
code: Code to execute
language: Programming language
timeout: Override timeout for this execution
memory_limit: Override memory limit for this execution
allow_network: Override network allowance for this execution
Returns:
ExecutionResult with output and status
"""
# Create temporary config if overrides are provided
if any(x is not None for x in [timeout, memory_limit, allow_network]):
config = SandboxConfig(
timeout=timeout or self.config.timeout,
memory_limit=memory_limit or self.config.memory_limit,
allow_network=allow_network if allow_network is not None else self.config.allow_network,
allow_file_ops=self.config.allow_file_ops,
max_output_size=self.config.max_output_size,
working_dir=self.config.working_dir,
env_vars=self.config.env_vars
)
# Temporarily update sandbox config
original_config = self.sandbox.config
self.sandbox.config = config
try:
result = self.sandbox.execute(code, language)
finally:
self.sandbox.config = original_config
else:
result = self.sandbox.execute(code, language)
return result
def validate(self, code: str, language: str) -> ValidationResult:
"""
Validate code without executing.
Args:
code: Code to validate
language: Programming language
Returns:
ValidationResult with any issues found
"""
return self.sandbox.validate_code(code, language)
def is_safe(self, code: str, language: str) -> bool:
"""
Quick check if code is safe to execute.
Args:
code: Code to check
language: Programming language
Returns:
True if code is safe, False otherwise
"""
validation = self.validate(code, language)
return validation.is_safe
def execute_with_retry(self,
code: str,
language: str = "python",
max_retries: int = 3,
**kwargs: Any) -> ExecutionResult:
"""
Execute code with automatic retry on transient failures.
Args:
code: Code to execute
language: Programming language
max_retries: Maximum number of retry attempts
**kwargs: Additional arguments passed to execute()
Returns:
ExecutionResult from successful execution or last failure
"""
last_result = None
for attempt in range(max_retries):
result = self.execute(code, language, **kwargs)
if result.success:
return result
# Check if error is retryable
if result.status == ExecutionStatus.TIMEOUT:
# Timeout errors are not retryable
return result
if result.status == ExecutionStatus.VALIDATION_FAILED:
# Validation errors are not retryable
return result
last_result = result
# Add retry metadata
if last_result.metadata is None:
last_result.metadata = {}
last_result.metadata['retry_attempt'] = attempt + 1
# Brief delay before retry
if attempt < max_retries - 1:
time.sleep(0.5 * (attempt + 1))
return last_result
def get_statistics(self) -> dict[str, Any]:
"""
Get execution statistics.
Returns:
Dictionary with execution statistics
"""
return {
"sandbox_type": self.sandbox_type,
"config": {
"timeout": self.config.timeout,
"memory_limit": self.config.memory_limit,
"allow_network": self.config.allow_network,
"allow_file_ops": self.config.allow_file_ops,
}
}
class ExecutionPool:
"""
Pool for managing multiple concurrent code executions.
Useful for batch processing or parallel execution of multiple code snippets.
"""
def __init__(self,
sandbox_type: str = "local",
config: SandboxConfig | None = None,
pool_size: int = 4) -> None:
"""
Initialize execution pool.
Args:
sandbox_type: Type of sandbox to use
config: Sandbox configuration
pool_size: Maximum number of concurrent executions
"""
self.sandbox_type = sandbox_type
self.config = config or SandboxConfig()
self.pool_size = pool_size
# Create executor pool
self.executors = [
CodeExecutor(sandbox_type, config)
for _ in range(pool_size)
]
self.available_executors = list(range(pool_size))
self.busy_executors = set()
def execute(self,
code: str,
language: str = "python",
**kwargs: Any) -> ExecutionResult:
"""
Execute code using an available executor from the pool.
Args:
code: Code to execute
language: Programming language
**kwargs: Additional execution arguments
Returns:
ExecutionResult
"""
# Get available executor
if not self.available_executors:
# Wait for an executor to become available
time.sleep(0.1)
if not self.available_executors:
raise RuntimeError("No executors available in pool")
executor_idx = self.available_executors.pop(0)
self.busy_executors.add(executor_idx)
try:
executor = self.executors[executor_idx]
result = executor.execute(code, language, **kwargs)
return result
finally:
# Return executor to pool
self.busy_executors.remove(executor_idx)
self.available_executors.append(executor_idx)
def execute_batch(self,
code_snippets: list[tuple[str, str]],
**kwargs: Any) -> list[ExecutionResult]:
"""
Execute multiple code snippets.
Args:
code_snippets: List of (code, language) tuples
**kwargs: Additional execution arguments
Returns:
List of ExecutionResult objects
"""
results = []
for code, language in code_snippets:
result = self.execute(code, language, **kwargs)
results.append(result)
return results
def get_pool_status(self) -> dict[str, Any]:
"""
Get pool status.
Returns:
Dictionary with pool status information
"""
return {
"pool_size": self.pool_size,
"available": len(self.available_executors),
"busy": len(self.busy_executors),
"utilization": len(self.busy_executors) / self.pool_size
}
class ExecutionHistory:
"""
Track execution history for debugging and analysis.
"""
def __init__(self, max_history: int = 1000) -> None:
"""
Initialize execution history.
Args:
max_history: Maximum number of executions to track
"""
self.max_history = max_history
self.history: list[dict[str, Any]] = []
self.execution_count = 0
self.success_count = 0
self.failure_count = 0
self.total_execution_time = 0.0
def record(self,
code: str,
language: str,
result: ExecutionResult) -> None:
"""
Record an execution.
Args:
code: Executed code
language: Programming language
result: Execution result
"""
entry = {
"id": self.execution_count,
"timestamp": time.time(),
"code": code,
"language": language,
"status": result.status.value,
"execution_time": result.execution_time,
"success": result.success,
"output_length": len(result.output),
"error_length": len(result.error)
}
self.history.append(entry)
# Limit history size
if len(self.history) > self.max_history:
self.history.pop(0)
# Update statistics
self.execution_count += 1
if result.success:
self.success_count += 1
else:
self.failure_count += 1
self.total_execution_time += result.execution_time
def get_statistics(self) -> dict[str, Any]:
"""
Get execution statistics.
Returns:
Dictionary with statistics
"""
return {
"total_executions": self.execution_count,
"success_count": self.success_count,
"failure_count": self.failure_count,
"success_rate": self.success_count / self.execution_count if self.execution_count > 0 else 0,
"average_execution_time": self.total_execution_time / self.execution_count if self.execution_count > 0 else 0,
"history_size": len(self.history)
}
def get_recent(self, n: int = 10) -> list[dict[str, Any]]:
"""
Get recent executions.
Args:
n: Number of recent executions to return
Returns:
List of execution records
"""
return self.history[-n:]
def clear(self) -> None:
"""Clear execution history."""
self.history.clear()
self.execution_count = 0
self.success_count = 0
self.failure_count = 0
self.total_execution_time = 0.0
class CodeExecutorWithHistory(CodeExecutor):
"""
Code executor that automatically tracks execution history.
"""
def __init__(self,
sandbox_type: str = "local",
config: SandboxConfig | None = None,
max_history: int = 1000) -> None:
"""
Initialize executor with history tracking.
Args:
sandbox_type: Type of sandbox
config: Sandbox configuration
max_history: Maximum history entries to keep
"""
super().__init__(sandbox_type, config)
self.history = ExecutionHistory(max_history)
def execute(self,
code: str,
language: str = "python",
**kwargs: Any) -> ExecutionResult:
"""
Execute code and record to history.
Args:
code: Code to execute
language: Programming language
**kwargs: Additional execution arguments
Returns:
ExecutionResult
"""
result = super().execute(code, language, **kwargs)
self.history.record(code, language, result)
return result
def get_statistics(self) -> dict[str, Any]:
"""
Get comprehensive statistics.
Returns:
Dictionary with executor and history statistics
"""
stats = super().get_statistics()
stats.update(self.history.get_statistics())
return stats

Xet Storage Details

Size:
28 kB
·
Xet hash:
a73b20f2495ee4ad2da7cf031f46cd6800e4192db5d7885968bf86ca4b7a48e7

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.