quick_run() Method

​

Supported Languages

​

Method Signature

​

async quick_run(runtime: Literal['C', 'C++', 'Java', 'Python', 'Node.js', 'SQLite', 'MySQL', 'Go', 'Rust', '.NET'], source_code: str, stdin: Optional[str] = None, expected_output: Optional[str] = None, additional_files_as_zip: Optional[str] = None) -> DecodedRunResult

​

Method Parameters

​

Required Parameters

​

Optional Parameters

​

Execution Results

​

Validation (if you provided expected_output)

• If the output matches: run_status.value will be "successful"
• If the output doesn’t match: run_status.value will be "wrong-answer"
• If there’s a compilation error: run_status.value will be "compilation-error"
• If there’s a runtime error: run_status.value will be "non-zero-exit-code" or another error status

​

How to Use quick_run()

import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="fermion-api-key")

    # Connect to sandbox first
    await sandbox.create(should_backup_filesystem=False)

    result = await sandbox.quick_run(
        runtime="Python",
        source_code='print("Hello, World!")'
    )

    # Output is already decoded
    if result.program_run_data:
        output = result.program_run_data.stdout
        print(output)          # "Hello, World!\n"
    print(result.run_status.value)  # "successful"

asyncio.run(main())

​

Error Handling

import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="fermion-api-key")
    await sandbox.create(should_backup_filesystem=False)  # Connect first (required)

    result = await sandbox.quick_run(
        runtime="Java",
        source_code='public class Main { // Missing closing brace'
    )

    print(result.run_status.value)  # "compilation-error"

    if result.compiler_output_after_compilation:
        # Output is already decoded by the SDK
        compiler_output = result.compiler_output_after_compilation
        print(compiler_output)  # Shows compiler error messages

asyncio.run(main())

import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="fermion-api-key")
    await sandbox.create(should_backup_filesystem=False)  # Connect first (required)

    result = await sandbox.quick_run(
        runtime="Python",
        source_code='print(1 / 0)'  # Division by zero
    )

    print(result.run_status.value)  # "non-zero-exit-code" or another error status

    if result.program_run_data and result.program_run_data.stderr:
        stderr_output = result.program_run_data.stderr
        print(stderr_output)  # Shows error details

asyncio.run(main())

import asyncio
from fermion_sandbox import Sandbox

async def main():
    sandbox = Sandbox(api_key="fermion-api-key")
    await sandbox.create(should_backup_filesystem=False)  # Connect first (required)

    result = await sandbox.quick_run(
        runtime="Python",
        source_code='while True: pass'  # Infinite loop
    )

    print(result.run_status.value)  # "time-limit-exceeded"

asyncio.run(main())

​

Best Practices

• Connect to the sandbox first: Always call await create() or await from_snippet() before using quick_run().
• Always check run_status first: Before reading output, confirm the code executed successfully (run_status.value == "successful").
• Ensure program_run_data is not None: Verify that the result object includes program_run_data before accessing its properties.
• Output is automatically decoded: The SDK automatically decodes stdout, stderr, and compiler_output_after_compilation. You can use them directly without additional decoding.
• Use expected_output for automated validation: If the output matches your expected value, run_status.value will be "successful", otherwise it will be "wrong-answer".
• Handle errors gracefully: Check run_status.value and read stderr to display meaningful error messages.
• Validate user input: Always validate and sanitize user-submitted code before execution to ensure safety and reliability.

​

Performance Tips

• Typical code execution time: 1–3 seconds
• Compiled languages (C++, Java, Rust) may take slightly longer due to compilation overhead.
• Interpreted languages (Python, Node.js) generally start faster.
• Database runtimes (SQLite, MySQL) depend on query complexity and data size.

​

Frequently Asked Questions