在Rust的pyO3中检查Python自定义类的实例类型

struct PyFinalRule(PyAny);

unsafe impl PyTypeInfo for PyFinalRule {
    const NAME: &'static str = "FinalRule";
    const MODULE: Option<&'static str> = Option::Some("LiSE.util");
    type AsRefTarget = PyAny;

    fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject {
        let modu = py.import("LiSE.util").unwrap();
        let final_rule = modu.getattr("FinalRule").unwrap();
        final_rule.get_type_ptr()
    }
}
unsafe impl PyNativeType for PyFinalRule {}

use pyo3::{PyResult, Python, types::PyAny};

fn get_final_rule_type<'py>(py: Python<'py>) -> PyResult<&'py PyAny> {
    let module = py.import("LiSE.util")?; // 导入包含FinalRule的模块
    let final_rule_type = module.getattr("FinalRule")?; // 获取FinalRule类对象
    Ok(final_rule_type)
}

fn is_instance_of_final_rule(py: Python<'_>, object: &PyAny) -> PyResult<bool> {
    let final_rule_type = get_final_rule_type(py)?; // 获取FinalRule类型对象
    object.is_instance(final_rule_type) // 检查object是否为final_rule_type的实例
}

use pyo3::{PyResult, Python, types::PyAny};

/// 检查一个PyAny对象是否为Python中定义的LiSE.util.FinalRule类的实例。
///
/// # 参数
/// - `py`: Python GIL令牌。
/// - `object`: 待检查的PyAny对象。
///
/// # 返回
/// 如果`object`是`FinalRule`的实例，则返回`Ok(true)`；否则返回`Ok(false)`。
/// 如果在导入模块或获取类时发生Python错误，则返回`Err(PyErr)`。
pub fn check_final_rule_instance(py: Python<'_>, object: &PyAny) -> PyResult<bool> {
    // 导入包含FinalRule类的Python模块
    let module = py.import("LiSE.util")?;
    // 从模块中获取FinalRule类对象
    let final_rule_class = module.getattr("FinalRule")?;
    // 使用PyAny::is_instance方法检查object是否为final_rule_class的实例
    object.is_instance(final_rule_class)
}

// 假设在Python中有一个LiSE/util.py文件，内容如下：
// class FinalRule:
//     pass
//
// class AnotherClass:
//     pass

// 示例用法（在Rust测试或实际应用中）：
#[cfg(test)]
mod tests {
    use super::*;
    use pyo3::{prelude::*, types::{PyDict, PyList}};

    #[test]
    fn test_final_rule_instance_check() -> PyResult<()> {
        pyo3::prepare_python(); // 初始化Python解释器

        Python::with_gil(|py| {
            // 模拟Python环境，创建LiSE.util模块和FinalRule类
            let sys = py.import("sys")?;
            let modules: &PyDict = sys.getattr("modules")?.downcast()?;
            let li_se_util = PyModule::new(py, "LiSE.util")?;
            li_se_util.add_class::<PyFinalRuleStub>()?; // 添加一个模拟的FinalRule类
            modules.set_item("LiSE.util", li_se_util)?;

            // 获取FinalRule类对象
            let final_rule_class = py.import("LiSE.util")?.getattr("FinalRule")?;

            // 创建FinalRule的实例
            let final_rule_instance = final_rule_class.call0()?;
            // 创建另一个类的实例
            let another_instance = py.eval("object()", None, None)?;
            // 创建一个Python列表
            let py_list = PyList::empty(py);

            // 检查实例
            assert!(check_final_rule_instance(py, final_rule_instance)?.is_ok());
            assert!(check_final_rule_instance(py, another_instance)?.is_err()); // 预期失败，因为不是FinalRule
            assert!(check_final_rule_instance(py, py_list)?.is_err()); // 预期失败，因为不是FinalRule

            Ok(())
        })
    }

    // 用于测试的模拟FinalRule类
    #[pyclass(name = "FinalRule", module = "LiSE.util")]
    struct PyFinalRuleStub {}

    #[pymethods]
    impl PyFinalRuleStub {
        #[new]
        fn new() -> Self {
            PyFinalRuleStub {}
        }
    }
}