Rust(pyo3) calls python(yolov8) blocking

Question

Problem brief description

I wrote the prediction for YOLOv8 in Python and called it in Pyo3, but it got stuck during the prediction phase. It's normal to execute the Python script separately。

You can clone this code from here:

https://github.com/Rainweic/ColorClassifier

you need to change the path of image

Code brief description

python code:

# yolov8.py
from ultralytics import YOLO


class YoloV8:

    def __init__(self):
        self.model = None

    def load_model(self, model_path):
        self.model = YOLO(model_path)

    def infer(self, img_path):
        res = self.model(img_path)
        return res


yolov8 = YoloV8()

rust code:

use pyo3::prelude::*;

static PYTHON_FILE_PATH: &str = include_str!("yolov8.py");

pub struct DetModule {
    pub instance: Option<Py<PyAny>>
}

impl DetModule {
    pub fn new() -> Self {

        let mut det_module = Self { instance: None };

        Python::with_gil(|py| {
            let det: &PyModule = PyModule::from_code(py, PYTHON_FILE_PATH, "", "")
                .expect("Load det module error");
            let instance: Py<PyAny> = det.getattr("yolov8")
                .expect("Get obj yolov8 failed").into();
            det_module.instance = Some(instance);
        });

        det_module
    }

    pub fn load_model(&mut self, model_file: &str) {
        Python::with_gil(|py| {
            let args = (model_file,);
            self.instance.as_ref().unwrap()
                .call_method1(py, "load_model", args)
                .expect("Load model {model_file} failed");
        });
    }

    pub fn infer(&self, img_path: &str) -> Option<PyObject> {
        let mut infer_res = None;

        Python::with_gil(|py| {
            let args = (img_path,);
            let res = self.instance.as_ref().unwrap()
                .call_method1(py, "infer", args)
                .expect("Infer error, img path: {img_path}");
            // infer_res = Some(res);
        });

        infer_res
    }
}


fn main() {

    let mut yolo_module = model::DetModule::new();
    yolo_module.load_model("yolov8n.pt");
    let res = yolo_module.infer("/Users/new/Downloads/car.png");
    match res {
        None => {}
        Some(res) => println!("res: {:?}", res)
    };
}

It doesn't feel like a deadlock, because when I run the py file alone it's predicted, and I add breakpoints with debugger and can't see exactly what line is stuck