Struct PythonOptions

pub struct PythonOptions {
    pub python_namespace: String,
    pub python_path: Vec<String>,
    pub imports: BTreeMap<String, HashSet<String>>,
    pub scope: Scope,
    pub stdpython: String,
    pub with_std_python: bool,
    pub allow_unsafe: bool,
    pub async_runtime: AsyncRuntime,
}

The global context for Python compilation.

Fields

python_namespace: String

Python imports are mapped into a given namespace that can be changed.

python_path: Vec<String>

The default path we will search for Python modules.

imports: BTreeMap<String, HashSet<String>>

Collects all of the things we need to compile imports[module][asnames]

scope: Scope

stdpython: String

with_std_python: bool

allow_unsafe: bool

async_runtime: AsyncRuntime

The async runtime to use for async Python code

Implementations

impl PythonOptions

pub fn with_tokio() -> Self

Create PythonOptions with tokio runtime (default)

pub fn with_async_std() -> Self

Create PythonOptions with async-std runtime

Examples found in repository

examples/async_runtime_example.rs (line 26)

fn main() {
    let python_code = r#"
import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data()
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
"#;

    // Example 1: Using tokio (default)
    println!("=== Example 1: Tokio (default) ===");
    let options = PythonOptions::default(); // tokio is the default
    generate_and_display(python_code, options);

    // Example 2: Using async-std
    println!("\n=== Example 2: async-std ===");
    let options = PythonOptions::with_async_std();
    generate_and_display(python_code, options);

    // Example 3: Using smol
    println!("\n=== Example 3: smol ===");
    let options = PythonOptions::with_smol();
    generate_and_display(python_code, options);

    // Example 4: Using custom runtime
    println!("\n=== Example 4: Custom runtime ===");
    let options = PythonOptions::with_custom_runtime("my_runtime::main", "my_runtime");
    generate_and_display(python_code, options);

    // Example 5: Programmatically setting runtime
    println!("\n=== Example 5: Programmatic configuration ===");
    let mut options = PythonOptions::default();
    options.set_async_runtime(AsyncRuntime::AsyncStd);
    generate_and_display(python_code, options);
}

pub fn with_smol() -> Self

Create PythonOptions with smol runtime

Examples found in repository

examples/async_runtime_example.rs (line 31)

fn main() {
    let python_code = r#"
import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data()
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
"#;

    // Example 1: Using tokio (default)
    println!("=== Example 1: Tokio (default) ===");
    let options = PythonOptions::default(); // tokio is the default
    generate_and_display(python_code, options);

    // Example 2: Using async-std
    println!("\n=== Example 2: async-std ===");
    let options = PythonOptions::with_async_std();
    generate_and_display(python_code, options);

    // Example 3: Using smol
    println!("\n=== Example 3: smol ===");
    let options = PythonOptions::with_smol();
    generate_and_display(python_code, options);

    // Example 4: Using custom runtime
    println!("\n=== Example 4: Custom runtime ===");
    let options = PythonOptions::with_custom_runtime("my_runtime::main", "my_runtime");
    generate_and_display(python_code, options);

    // Example 5: Programmatically setting runtime
    println!("\n=== Example 5: Programmatic configuration ===");
    let mut options = PythonOptions::default();
    options.set_async_runtime(AsyncRuntime::AsyncStd);
    generate_and_display(python_code, options);
}

pub fn with_custom_runtime( attribute: impl Into<String>, import: impl Into<String>, ) -> Self

Create PythonOptions with a custom async runtime

Examples found in repository

examples/async_runtime_example.rs (line 36)

fn main() {
    let python_code = r#"
import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data()
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
"#;

    // Example 1: Using tokio (default)
    println!("=== Example 1: Tokio (default) ===");
    let options = PythonOptions::default(); // tokio is the default
    generate_and_display(python_code, options);

    // Example 2: Using async-std
    println!("\n=== Example 2: async-std ===");
    let options = PythonOptions::with_async_std();
    generate_and_display(python_code, options);

    // Example 3: Using smol
    println!("\n=== Example 3: smol ===");
    let options = PythonOptions::with_smol();
    generate_and_display(python_code, options);

    // Example 4: Using custom runtime
    println!("\n=== Example 4: Custom runtime ===");
    let options = PythonOptions::with_custom_runtime("my_runtime::main", "my_runtime");
    generate_and_display(python_code, options);

    // Example 5: Programmatically setting runtime
    println!("\n=== Example 5: Programmatic configuration ===");
    let mut options = PythonOptions::default();
    options.set_async_runtime(AsyncRuntime::AsyncStd);
    generate_and_display(python_code, options);
}

pub fn set_async_runtime(&mut self, runtime: AsyncRuntime) -> &mut Self

Set the async runtime for these options

Examples found in repository

examples/async_runtime_example.rs (line 42)

fn main() {
    let python_code = r#"
import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data()
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
"#;

    // Example 1: Using tokio (default)
    println!("=== Example 1: Tokio (default) ===");
    let options = PythonOptions::default(); // tokio is the default
    generate_and_display(python_code, options);

    // Example 2: Using async-std
    println!("\n=== Example 2: async-std ===");
    let options = PythonOptions::with_async_std();
    generate_and_display(python_code, options);

    // Example 3: Using smol
    println!("\n=== Example 3: smol ===");
    let options = PythonOptions::with_smol();
    generate_and_display(python_code, options);

    // Example 4: Using custom runtime
    println!("\n=== Example 4: Custom runtime ===");
    let options = PythonOptions::with_custom_runtime("my_runtime::main", "my_runtime");
    generate_and_display(python_code, options);

    // Example 5: Programmatically setting runtime
    println!("\n=== Example 5: Programmatic configuration ===");
    let mut options = PythonOptions::default();
    options.set_async_runtime(AsyncRuntime::AsyncStd);
    generate_and_display(python_code, options);
}

Trait Implementations

impl Clone for PythonOptions

fn clone(&self) -> PythonOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PythonOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PythonOptions

fn default() -> Self

Returns the “default value” for a type.