Rust PyO3 - 如何执行未知模块导入的脚本？

当您使用 PyO3 从 Rust 执行 Python 代码时，尤其是在处理具有在编译时未知的导入的 Python 脚本时，您需要一种方法让 Python 解释器正确解析和导入这些依赖关系。这里的关键是确保 Python 的导入系统知道这些模块所在的目录。

use pyo3::types::PyString;
use pyo3::prelude::*;
use pyo3::types::{PyList, PyModule};
use walkdir::WalkDir;
use std::path::Path;

// Making `WatchCommand` public
pub struct WatchCommand {
    pub main: String,
}

pub fn python(args: &WatchCommand) -> PyResult<()> {
    let main = Path::new(&args.main);
    let parent = main.parent().unwrap();
    println!("Loading Python Module...");
    let file_contents = std::fs::read_to_string(&args.main)?;

    Python::with_gil(|py| -> PyResult<()> {
        let sys = py.import("sys")?;
        let path: &PyList = sys.getattr("path")?.extract()?;
        path.insert(0, pyo3::IntoPy::<Py<PyString>>::into_py(parent.to_str().unwrap(), py))?;

        for entry in WalkDir::new(parent) {
            let entry = entry.map_err(|e| PyErr::from(std::io::Error::new(std::io::ErrorKind::Other, e)))?;
            if entry.path().is_file() && entry.path().extension().unwrap_or_default() == "py" {
                let file_content = std::fs::read_to_string(entry.path())?;
                let name = entry.path().file_stem().unwrap().to_str().unwrap();
                PyModule::from_code(py, &file_content, name, name)?;
                println!("Loading module: {:?}", entry.path());
            }
        }

        let main = PyModule::from_code(py, &file_contents, "main.py", "main")?;
        let result: i16 = main.getattr("main")?.call0()?.extract()?;
        println!("Result of main(): {}", result);

        Ok(())
    })
}

fn main() -> PyResult<()> {
    let args = WatchCommand {
        main: "/home/adesoji/pyo3_test/main.py".to_string(),
    };

    python(&args)
}

my cargo.toml file below

[package]
name = "pyo3_test"
version = "0.1.0"
edition = "2021"
Author = "Adesoji Alu , [email protected]"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
pyo3 = { version = "0.20.0", features = ["extension-module"] }
walkdir = "2.3"

now what i did was i ensured the Rust code dynamically loads Python modules from the same directory where the rust project exists as you can see the main.py script's path. This means that any import statements in my main.py that reference other Python files in the same directory should work correctly, as these files are being dynamically loaded into the Python interpreter's module path.

For example, if main.py imports a module testmod, and both main.py and testmod.py are in the same directory (/home/adesoji/pyo3_test/ in my case), the Rust code will load testmod.py into the Python interpreter, allowing main.py to import testmod without encountering a "ModuleNotFoundError".

my approach is particularly useful when you have a Python project with multiple modules and you want to invoke it from Rust while ensuring all Python module dependencies are correctly resolved. i hope this works for you because i used a Linux ubuntu 20.04. you could look at this documentation here from rust: https://docs.rs/pyo3/latest/pyo3/