Contributing to LLM Sandbox¶

# tests/test_your_feature.py
import pytest
from llm_sandbox import YourFeature

def test_your_feature():
    """Test description"""
    # Arrange
    feature = YourFeature()

    # Act
    result = feature.do_something()

    # Assert
    assert result == expected_value

@pytest.mark.parametrize("input,expected", [
    ("input1", "output1"),
    ("input2", "output2"),
])
def test_parametrized(input, expected):
    """Test with multiple inputs"""
    assert process(input) == expected

# llm_sandbox/language_handlers/rust_handler.py
from .base import AbstractLanguageHandler, LanguageConfig

class RustHandler(AbstractLanguageHandler):
    def __init__(self, logger=None):
        super().__init__(logger)
        self.config = LanguageConfig(
            name="rust",
            file_extension="rs",
            execution_commands=["rustc {file} -o /tmp/program && /tmp/program"],
            package_manager="cargo add",
        )

    def get_import_patterns(self, module: str) -> str:
        return rf"use\s+{module}"

    # Implement other required methods...

# llm_sandbox/language_handlers/factory.py
from .rust_handler import RustHandler

class LanguageHandlerFactory:
    _handlers = {
        # ...
        "rust": RustHandler,
    }

# llm_sandbox/const.py
class SupportedLanguage(StrEnum):
    # ...
    RUST = "rust"

class DefaultImage:
    # ...
    RUST = "rust:latest"

# tests/test_rust_handler.py
def test_rust_execution():
    with SandboxSession(lang="rust") as session:
        result = session.run('fn main() { println!("Hello"); }')
        assert result.stdout.strip() == "Hello"

# llm_sandbox/new_backend.py
from .base import Session

class SandboxNewBackendSession(Session):
    def open(self):
        # Implementation
        pass

    def close(self):
        # Implementation
        pass

    # Implement all abstract methods...

# llm_sandbox/session.py
def create_session(backend, **kwargs):
    match backend:
        # ...
        case SandboxBackend.NEW_BACKEND:
            from .new_backend import SandboxNewBackendSession
            return SandboxNewBackendSession(**kwargs)

# llm_sandbox/const.py
class SandboxBackend(StrEnum):
    # ...
    NEW_BACKEND = "new_backend"

# Use pytest fixtures for reusable components
@pytest.fixture
def sandbox_session():
    with SandboxSession(lang="python") as session:
        yield session

# Group related tests
class TestSecurityPolicies:
    def test_pattern_detection(self):
        # Test implementation
        pass

    def test_module_restriction(self):
        # Test implementation
        pass

# Use parametrize for multiple test cases
@pytest.mark.parametrize("backend", [
    SandboxBackend.DOCKER,
    SandboxBackend.PODMAN,
])
def test_cross_backend(backend):
    # Test implementation
    pass

from unittest.mock import Mock, patch

@patch('docker.from_env')
def test_docker_connection(mock_docker):
    mock_client = Mock()
    mock_docker.return_value = mock_client

    session = SandboxSession(backend=SandboxBackend.DOCKER)
    # Test implementation

def execute_code(code: str, language: str = "python") -> ConsoleOutput:
    """Execute code in a sandboxed environment.

    This function creates an isolated container environment and
    executes the provided code safely.

    Args:
        code: The source code to execute
        language: Programming language identifier

    Returns:
        ConsoleOutput containing stdout, stderr, and exit code

    Raises:
        SecurityError: If code violates security policy
        NotOpenSessionError: If session is not initialized

    Example:
        >>> result = execute_code("print('Hello')")
        >>> print(result.stdout)
        Hello
    """

from typing import Optional, List, Dict, Union, Any
from typing import Protocol  # for protocols

def process_data(
    data: List[Dict[str, Any]],
    options: Optional[Dict[str, Union[str, int]]] = None
) -> Dict[str, Any]:
    """Process data with options."""
    pass

def use_special_feature():
    # Import only when function is called
    import heavy_library
    return heavy_library.process()

# Good
with SandboxSession() as session:
    result = session.run(code)

# Avoid
session = SandboxSession()
session.open()
result = session.run(code)
session.close()  # May not be called if error occurs

from functools import lru_cache

@lru_cache(maxsize=128)
def get_language_handler(language: str):
    return LanguageHandlerFactory.create_handler(language)