implement PyTypeInfo on PyWeakref and PyWeakrefProxy

Create a new ABC class and make the relevant classes virtual subclasses of it

Author: Tpt

newsfragments/5401.added.md

@@ -0,0 +1 @@
+Implement `PyTypeInfo` on `PyWeakref` and `PyWeakrefProxy` using dynamically generated ABC classes

src/types/weakref/anyref.rs

@@ -1,31 +1,42 @@
 use crate::err::PyResult;
 use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::sync::PyOnceLock;
 use crate::type_object::{PyTypeCheck, PyTypeInfo};
 use crate::types::any::PyAny;
-use crate::{ffi, Bound};
+use crate::types::{PyAnyMethods, PyDict, PyType, PyTypeMethods};
+use crate::{ffi, Bound, Py};
 
 /// Represents any Python `weakref` reference.
 ///
 /// In Python this is created by calling `weakref.ref` or `weakref.proxy`.
 #[repr(transparent)]
 pub struct PyWeakref(PyAny);
 
-pyobject_native_type_named!(PyWeakref);
+pyobject_native_type_core!(
+    PyWeakref,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.get_or_try_init(py, || {
+            // Terrible way to generate a super class of both ProxyType and CallableProxyType
+            let globals = PyDict::new(py);
+            globals.set_item("abc", py.import("abc")?)?;
+            py.run(ffi::c_str!("class Weakref(abc.ABC):\n    pass"), Some(&globals), None)?;
+            let cls = globals.get_item("Weakref")?.downcast_into::<PyType>()?;
+            let weakref = py.import("weakref")?;
+            for child_name in ["ProxyType", "CallableProxyType", "ReferenceType"] {
+                cls.call_method1("register", (weakref.getattr(child_name)?,))?;
+            }
+            PyResult::Ok(cls.unbind())
+        }).unwrap().bind(py).as_type_ptr()
+    },
+    #module=Some("weakref"),
+    #checkfunction=ffi::PyWeakref_Check
+);
 
 // TODO: We known the layout but this cannot be implemented, due to the lack of public typeobject pointers
 // #[cfg(not(Py_LIMITED_API))]
 // pyobject_native_type_sized!(PyWeakref, ffi::PyWeakReference);
 
-impl PyTypeCheck for PyWeakref {
-    const NAME: &'static str = "weakref";
-    #[cfg(feature = "experimental-inspect")]
-    const PYTHON_TYPE: &'static str = "weakref.ProxyTypes";
-
-    fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        unsafe { ffi::PyWeakref_Check(object.as_ptr()) > 0 }
-    }
-}
-
 /// Implementation of functionality for [`PyWeakref`].
 ///
 /// These methods are defined for the `Bound<'py, PyWeakref>` smart pointer, so to use method call

src/types/weakref/proxy.rs

@@ -1,11 +1,11 @@
 use crate::err::PyResult;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::py_result_ext::PyResultExt;
-use crate::type_object::PyTypeCheck;
+use crate::sync::PyOnceLock;
 use crate::types::any::PyAny;
-use crate::{ffi, Borrowed, Bound, BoundObject, IntoPyObject, IntoPyObjectExt};
-
-use super::PyWeakrefMethods;
+use crate::types::weakref::PyWeakrefMethods;
+use crate::types::{PyAnyMethods, PyDict, PyType, PyTypeMethods};
+use crate::{ffi, Borrowed, Bound, BoundObject, IntoPyObject, IntoPyObjectExt, Py};
 
 /// Represents any Python `weakref` Proxy type.
 ///
@@ -14,22 +14,31 @@ use super::PyWeakrefMethods;
 #[repr(transparent)]
 pub struct PyWeakrefProxy(PyAny);
 
-pyobject_native_type_named!(PyWeakrefProxy);
+pyobject_native_type_core!(
+    PyWeakrefProxy,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.get_or_try_init(py, || {
+            // Terrible way to generate a super class of both ProxyType and CallableProxyType
+            let globals = PyDict::new(py);
+            globals.set_item("abc", py.import("abc")?)?;
+            py.run(ffi::c_str!("class WeakrefProxy(abc.ABC):\n    pass"), Some(&globals), None)?;
+            let cls = globals.get_item("WeakrefProxy")?.downcast_into::<PyType>()?;
+            let weakref = py.import("weakref")?;
+            for child_name in ["ProxyType", "CallableProxyType"] {
+                cls.call_method1("register", (weakref.getattr(child_name)?,))?;
+            }
+            PyResult::Ok(cls.unbind())
+        }).unwrap().bind(py).as_type_ptr()
+    },
+    #module=Some("weakref"),
+    #checkfunction=ffi::PyWeakref_CheckProxy
+);
 
 // TODO: We known the layout but this cannot be implemented, due to the lack of public typeobject pointers. And it is 2 distinct types
 // #[cfg(not(Py_LIMITED_API))]
 // pyobject_native_type_sized!(PyWeakrefProxy, ffi::PyWeakReference);
 
-impl PyTypeCheck for PyWeakrefProxy {
-    const NAME: &'static str = "weakref.ProxyTypes";
-    #[cfg(feature = "experimental-inspect")]
-    const PYTHON_TYPE: &'static str = "weakref.ProxyType | weakref.CallableProxyType";
-
-    fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        unsafe { ffi::PyWeakref_CheckProxy(object.as_ptr()) > 0 }
-    }
-}
-
 /// TODO: UPDATE DOCS
 impl PyWeakrefProxy {
     /// Constructs a new Weak Reference (`weakref.proxy`/`weakref.ProxyType`/`weakref.CallableProxyType`) for the given object.
@@ -183,7 +192,7 @@ mod tests {
     use crate::exceptions::{PyAttributeError, PyReferenceError, PyTypeError};
     use crate::types::any::{PyAny, PyAnyMethods};
     use crate::types::weakref::{PyWeakrefMethods, PyWeakrefProxy};
-    use crate::{Bound, PyResult, Python};
+    use crate::{Bound, PyResult, PyTypeInfo, Python};
 
     #[cfg(all(Py_3_13, not(Py_LIMITED_API)))]
     const DEADREF_FIX: Option<&str> = None;
@@ -412,6 +421,18 @@ mod tests {
                     Ok(())
                 })
             }
+
+            #[test]
+            fn test_type_object() -> PyResult<()> {
+                Python::attach(|py| {
+                    let t = PyWeakrefProxy::type_object(py);
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+                    assert!(reference.is_instance(&t)?);
+                    Ok(())
+                })
+            }
         }
 
         // under 'abi3-py37' and 'abi3-py38' PyClass cannot be weakreferencable.
@@ -718,6 +739,17 @@ mod tests {
                     Ok(())
                 })
             }
+
+            #[test]
+            fn test_type_object() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+                    assert!(reference.is_instance(&PyWeakrefProxy::type_object(py))?);
+                    Ok(())
+                })
+            }
         }
 
         // under 'abi3-py37' and 'abi3-py38' PyClass cannot be weakreferencable.