Question: function overriding doesn't seem to work in python

[shi-yan]

Hello,

I have a framework in python, now I want to rewrite it in rust using pyo3.

The framework has a Base class for users to inherent, in the child class, a user would provide implementation for a function "do_work". And my framework (the base class) will call that "do_work" function.

But the same paradigm doesn't seem to work with pyo3

I have the following in rust:

#[pyclass(subclass)]
struct MyClass {
    num: i32,
    debug: bool,
}

#[pymethods]
impl MyClass {
    #[new]
    fn new() -> Self {
        MyClass { num:32, debug: false }
    }

    #[classmethod]
    fn print_test(cls: &PyType) -> PyResult<i32> {
        println!("print from rust: {}", 23);
        let gil = Python::acquire_gil();
        let py = gil.python();
        cls.call_method("override_test", (), None);
        Ok(32)
    }

    #[classmethod]
    fn override_test(cls: &PyType) -> PyResult<i32> {
        println!("print within rust");
        Ok(600)
    }
}

and this in python

class Test(testbed.MyClass):
    def __init__(self):
        self.debug = 32
        testbed.MyClass.__init__(self)

    def override_test(self):
        print("print within python")
        self.debug = 43
        return 453
    
demo = Test()
demo.print_test()
print("test result: ", demo.debug )

If I don't provide override_test in the child class "Test", things would work as expected. I would see print within rust

But if I provide an overriden function in the child class, this overriden function won't be called by the rust parent class.

[davidhewitt]

Hi, there's two problems with your snippet above:

• You're ignoring the error when you call cls.call_method. The compiler is even warning you this:

  warning: unused `Result` that must be used 35/36: pyo3-scratch
  --> src/lib.rs:19:9
     |
  19 |         cls.call_method("override_test", (), None);
     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     |
     = note: `#[warn(unused_must_use)]` on by default
     = note: this `Result` may be an `Err` variant, which should be handled
  

• Your override in Python is not a classmethod.

If I add ? at the end of cls_call_method(...)?;, so that the error is correctly propagated, so the print_test function looks like this:

    #[classmethod]
    fn print_test(cls: &PyType) -> PyResult<i32> {
        println!("print from rust: {}", 23);
        cls.call_method("override_test", (), None)?;  // <--- note: trailing ?
        Ok(32)
    }

Then I get this output from the Python script:

$ ./test.py
print from rust: 23
Traceback (most recent call last):
  File "/home/david/dev/pyo3-scratch/./test.py", line 17, in <module>
    demo.print_test()
TypeError: override_test() missing 1 required positional argument: 'self'

... which is a crash caused by the second error.

[shi-yan]

Thank you! I now know the issue. but I still can't make it to work, because in the rust function print_test, I don't know how to get a reference to the Object itself to call the other function override_test , I can't find a single example showing that. directly calling self.override_test() doesn't work.

#[pymethods]
impl MyClass {
    #[new]
    fn new() -> Self {
        MyClass { num:32, debug: false }
    }

    fn print_test(&self, py: Python) -> PyResult<i32> {
        println!("print from rust: {}", 23);
        let gil = Python::acquire_gil();
        let py = gil.python();
        //I'm not sure what I should do here?
        //self.call_method("override_test", (), None)?;
        self.override_test(); // doesn't trigger the overriden function
        Ok(32)
    }

    fn override_test(&self) -> PyResult<i32> {
        println!("print within rust");
        Ok(600)
    }
}

_self_.call_method("override_test", (), None)?;
or 
py.call_method(_self_, "override_test")?;

[davidhewitt]

Try this:

    fn print_test(slf: &PyCell<Self>) -> PyResult<i32> {
        println!("print from rust: {}", 23);
        slf.call_method("override_test", (), None)?;
        Ok(32)
    }

[shi-yan]

that worked like a charm! thank you!