在Rust pyO3中高效检查Python自定义类实例的正确方法

use pyo3::{prelude::*, types::PyAny};
use pyo3::class::basic::PyObject; // For PyNativeType if needed, but not directly relevant to the instance check issue

// 示例：用户尝试定义一个Rust结构体来代表Python中的FinalRule类
struct PyFinalRule(PyAny);

// 尝试实现PyTypeInfo
// 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 pyo3::ffi::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 {} // 如果FinalRule是Python原生类型，但这里是自定义类型

// 这种方法的问题在于：
// PyFinalRule::is_type_of(py_instance) 总是返回 false。
// 它只能正确判断传入的是否是 FinalRule *类型对象* 本身，而不是 FinalRule *实例*。

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

/// 检查一个PyAny对象是否是Python模块'LiSE.util'中'FinalRule'类的实例。
///
/// # 参数
/// - `py`: Python GIL令牌。
/// - `object`: 需要检查的PyAny对象。
///
/// # 返回
/// 如果对象是FinalRule的实例，则返回`Ok(true)`；否则返回`Ok(false)`。
/// 如果导入模块或获取属性失败，则返回`PyResult`错误。
fn is_instance_of_final_rule(py: Python<'_>, object: &PyAny) -> PyResult<bool> {
    // 1. 导入包含自定义类的Python模块
    let module = py.import("LiSE.util")?;
    // 2. 从模块中获取自定义类的类型对象
    let final_rule_type = module.getattr("FinalRule")?;
    // 3. 使用PyAny::is_instance方法检查对象是否为该类型的实例
    object.is_instance(final_rule_type)
}

// 示例用法（假设在Python环境中调用）：
#[pyfunction]
fn check_final_rule_instance(py: Python<'_>, obj: &PyAny) -> PyResult<bool> {
    is_instance_of_final_rule(py, obj)
}

#[pymodule]
fn my_rust_module(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(check_final_rule_instance, m)?)?;
    Ok(())
}

// 对应的Python代码（用于测试）
/*
# LiSE/util.py
class FinalRule:
    def __init__(self, value):
        self.value = value

# main.py
import my_rust_module
from LiSE.util import FinalRule

instance = FinalRule(10)
not_instance = "hello"
another_object = [1, 2, 3]

print(f"Is instance a FinalRule? {my_rust_module.check_final_rule_instance(instance)}")
print(f"Is not_instance a FinalRule? {my_rust_module.check_final_rule_instance(not_instance)}")
print(f"Is another_object a FinalRule? {my_rust_module.check_final_rule_instance(another_object)}")
*/

use pyo3::{prelude::*, types::PyAny, PyResult};
use once_cell::sync::OnceCell; // 需要在Cargo.toml中添加once_cell = "1.x"

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

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

/// 检查一个PyAny对象是否是Python模块'LiSE.util'中'FinalRule'类的实例。
fn is_instance_of_final_rule_cached(py: Python<'_>, object: &PyAny) -> PyResult<bool> {
    let final_rule_type = get_final_rule_type(py)?;
    object.is_instance(final_rule_type)
}

#[pyfunction]
fn check_final_rule_instance_cached(py: Python<'_>, obj: &PyAny) -> PyResult<bool> {
    is_instance_of_final_rule_cached(py, obj)
}

#[pymodule]
fn my_rust_module_cached(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(check_final_rule_instance_cached, m)?)?;
    Ok(())
}