Writing a Mixin, how to call the super "new" and carry its value to the subclasses.

[llacroix]

In a different question, I found out the py_super method doesn't really help calling the real super method and it has to be called as such:

let super_ = PySuper::new(Mixin::get_type(self_.py()), self_)?;
let result = super_.call_method("super_method", (), None)?;

Then it seems it's possible to have a reference to the class by making new a class method.

So something like this can be used:

#[new]
#[classmethod]
fn new<'p>(cls: &'p PyType, py: Python<'p>) -> PyResult<Self> {
  let super_ = PySuper::new(Mixin::get_type(py), cls)?;
  let result = super_.call_method("__new__", (cls,), None)?;
  Ok(Mixin {})
}

This will call the __new__ of the base super class but for some reasons it fails with:

TypeError: object.__new__(B) is not safe, use builtins.Mixin.__new__()

But in reality the builtins.Mixin.__new__ is indeed called.

Here's a more complete code snippet:

rust:

use pyo3::prelude::*;
use pyo3::PyTypeInfo;
use pyo3::types::{PySuper, PyType};

#[derive(Debug)]
#[pyclass(subclass)]
struct Mixin {}

#[pymethods]
impl Mixin {
 #[new]
 #[classmethod]
 fn new<'p>(cls: &'p PyType, py: Python<'p>) -> PyResult<Self> {
   let super_ = PySuper::new(Mixin::type_object(py), cls)?;
   let result = super_.call_method("__super__", (cls,), None)?;
   Ok(Mixin {})
 }
} 

#[pymodule]
fn rust_mixins(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
  m.add_class::<Mixin>()?;
  Ok(())
}

Python code:

from rust_mixins import Mixin

class A(object):
    def __new__(cls):
        return super().__new__(cls)

class B(Mixin, A):
   def __new__(cls):
        return super().__new__(cls)

b = B()

This will fail in A.new when calling super (object.__new__)

It's as if PyO3 had to mark the __new__ method has called, but it doesn't and Python thinks it didn't call the builtin method.

[davidhewitt]

I think the error that's firing is this one: https://github.com/python/cpython/blob/0566ab9c4d966c7280a1c02fdeea8129ba65de81/Objects/typeobject.c#L8318

[davidhewitt]

From reading the comment, it looks to me like the check might be not quite right in this case, as Mixin is a heaptype but it's being treated as a static base. I think this needs to be reported upstream, probably easiest to come up with a pure-C repro for the Python devs.