Support for classattr and getter on pyclass attribute of the same name

Hi, I'd like to make a pyclass with a classattr and regular attribute with the same name. See this example:

#[pyclass]
struct PyO3Class {
    #[pyo3(get, set)]
    attr: i32,
}

#[pymethods]
impl PyO3Class {
    #[new]
    fn new(attr: i32) -> Self {
        Self { attr }
    }

    #[classattr]
    fn attr() -> String {
        "From the class".to_string()
    }
}

My expectation based on standard Python behaviour is that when I access .attr on a class, I should get the string from the classattr, whereas on an instance I get the integer value out from the instance.

See this Python code demonstrating this:

class PythonClass:
    attr: str = "From the class"

    def __init__(self, attr: int) -> None:
        self.attr = attr


python_instance = PythonClass(123)
print("PythonClass.attr", PythonClass.attr)
print("instance.attr", python_instance.attr)

outputting:

PythonClass.attr From the class
instance.attr 123

However, from PyO3 class above, the equivalent code:

from example import PyO3Class

pyo3_instance = PyO3Class(123)
print("PyO3Class.attr", PyO3Class.attr)
print("pyo3_instance.attr", pyo3_instance.attr)

outputs:

PyO3Class.attr From the class
pyo3_instance.attr From the class

I've tried a few other patterns to try and get this to work:

• Implement a #[getter] explicitly and play with the order
• Do inheritance and have the classattr in the base class
• Call PyO3Class::type_object(py).setattr("attr", "From the class") on module initialisation

However all resulted in the same behaviour.

I've opened this issue as suggested by @davidhewitt on Discord.

Start with the pyclass and pymethods handling for #[pyo3(get, set)] attributes and #[classattr], then reproduce the Rust and Python examples from the issue. Done means class access returns the class attribute while instance access returns the instance value when both share the same name.