pyO3中从Rust检查Python自定义类实例类型的方法

use pyo3::{prelude::*, types::PyAny};

/// 检查一个PyAny对象是否为Python中LiSE.util.FinalRule类的实例
fn is_instance_of_final_rule(py: Python<'_>, object: &PyAny) -> PyResult<bool> {
    // 1. 导入包含目标类的Python模块
    let module = py.import("LiSE.util")?;

    // 2. 从模块中获取目标自定义类的类型对象
    // 这里的'final_rule'变量现在持有Python中LiSE.util.FinalRule类的类型对象
    let final_rule_type_object = module.getattr("FinalRule")?;

    // 3. 使用PyAny::is_instance()方法进行类型检查
    // 此方法会判断'object'是否是'final_rule_type_object'的实例
    object.is_instance(final_rule_type_object)
}

// 假设在Python环境中有一个名为LiSE.util的模块，其中定义了FinalRule类
// 可以在Python中这样定义：
// # LiSE/util.py
// class FinalRule:
//     pass
//
// # 示例用法（在Rust测试中或实际调用时）
// #[cfg(test)]
// mod tests {
//     use super::*;
//     use pyo3::types::PyModule;
//
//     #[test]
//     fn test_is_instance_of_final_rule() -> PyResult<()> {
//         pyo3::prepare_python(); // 初始化Python解释器
//         Python::with_gil(|py| {
//             // 模拟Python环境中的模块和类
//             let util_module = PyModule::new(py, "LiSE.util")?;
//             let final_rule_class = PyClassInitializer::new(
//                 py.get_type_bound::<pyo3::types::PyType>()
//                     .call1((pyo3::intern!(py, "FinalRule"), py.empty_tuple(), py.empty_dict()))?
//             ).create_bound(py)?;
//             util_module.setattr("FinalRule", final_rule_class)?;
//
//             // 创建一个FinalRule的实例
//             let final_rule_instance = final_rule_class.call0()?;
//
//             // 检查实例
//             assert!(is_instance_of_final_rule(py, final_rule_instance.as_ref())?);
//
//             // 检查非实例
//             let some_int = 123.to_object(py);
//             assert!(!is_instance_of_final_rule(py, some_int.as_ref())?);
//
//             // 检查类型对象本身（is_instance对于类型对象会返回false，因为它不是自己的实例）
//             assert!(!is_instance_of_final_rule(py, final_rule_class.as_ref())?);
//
//             Ok(())
//         })
//     }
// }

use pyo3::{prelude::*, types::PyAny};
use once_cell::sync::OnceCell; // 用于线程安全的单例初始化

// 使用OnceCell来惰性初始化并缓存FinalRule的类型对象
static FINAL_RULE_TYPE_OBJECT: OnceCell<PyObject> = OnceCell::new();

/// 获取并缓存LiSE.util.FinalRule的类型对象
fn get_final_rule_type_object(py: Python<'_>) -> PyResult<&PyObject> {
    FINAL_RULE_TYPE_OBJECT.get_or_try_init(|| {
        let module = py.import("LiSE.util")?;
        let final_rule = module.getattr("FinalRule")?;
        Ok(final_rule.into()) // 将PyBound<_, PyAny>转换为PyObject，以便存储
    })
}

/// 检查一个PyAny对象是否为Python中LiSE.util.FinalRule类的实例（使用缓存）
fn is_instance_of_final_rule_cached(py: Python<'_>, object: &PyAny) -> PyResult<bool> {
    let final_rule_type_object = get_final_rule_type_object(py)?;
    // 将PyObject转换为PyAny以便is_instance使用
    object.is_instance(final_rule_type_object.as_ref(py))
}