Accessing class attributes within nested classes: AttributeError: 'getset_descriptor' object has no attribute '...'

[DavidAntliff]

I am looking to port an existing Python data structure to Rust via PyO3.

The original code uses nested classes, and class attributes, to represent a static and constant data structure:

class System:
    name: "MySystem"

    class Cpu:
        fclk: 50e6

Note that these classes are never instantiated, instead they are consumed by code as read-only constants, such as:

print(f"CPU clock: {System.Cpu.fclk} Hz")

Essentially, classes are used only as namespaces.

With PyO3 I seem to have run into an issue with classattr in nested classes:

#[pyclass]
struct System {
    #[pyo3(get)]
    Cpu: Cpu,
}

#[pymethods]
impl System {
    #[classattr]
    const name: &'static str = "MySystem";
}

#[pyclass]
struct Cpu {}

#[pymethods]
impl Cpu {
    #[classattr]
    const fclk: f64 = 50e6;
}

// #[pymodule] omitted for brevity

With this definition, the following works OK:

>>> from pyo3_ext import System, Cpu
>>> print(System.name)
MySystem
>>> print(Cpu.fclk)
50000000.0

But attempting to access the inner class attribute via the full hierarchy fails:

>>> from pyo3_ext import System
>>> print(System.Cpu.fclk)
AttributeError: 'getset_descriptor' object has no attribute 'fclk'

Is there a way to implement this static hierarchy with PyO3?

[alex]

#[pyclass]
struct System {
    #[pyo3(get)]
    Cpu: Cpu,
}

This puts a Cpu attribute on instances of System, it doesn't put it on the System class itself.

You need to use something like classattr to put an attribute on the class.

[DavidAntliff]

Ah, of course - that makes perfect sense, thank you. I will see what I can do...

EDIT: yes, that worked - thank you again:

#[pymethods]
impl System {
    #[classattr]
    const Cpu: Cpu = Cpu {};
}

[DavidAntliff]

So this works well in most cases, but there's still a quirk with nested classes.

I have a test function that walks the hierarchy to make sure that the PyO3 "drop in" implementation matches the original Python code. To do this, it looks for classes within classes (as above) and compares class attributes for equality. But for whatever reason, the inspect module treats nested PyO3 classes differently from the top-level ones.

Given the code above:

>>> import inspect

# Original class hierarchy:
>>> inspect.isclass(System)
True
>>> inspect.isclass(System.Cpu)
True

# New PyO3 hierarchy:
>>> from pyo3_ext import System
>>> inspect.isclass(System)
True
>>> inspect.isclass(System.Cpu)
False

Here's what inspect.getmembers(System) "sees" with the PyO3 module:

[('Cpu', <builtins.Cpu object at 0x7f5b1b599a50>),

Whereas the original Python one is reported as:

[('Cpu', <class '__main__.System.Cpu'>),

Ultimately, I want to be able to determine that Cpu is itself a class (so I can walk its attributes to generate test cases). I can use the following as a test, but it is only a partial test (in my case I can use it because I know if this succeeds it must be a PyO3 class):

>>> type(System)
<class 'type'>
>>> type(System.Cpu)
<class 'builtins.Cpu'>

>>> str(type(System.Cpu)).startswith("<class 'builtins.")
True

# But:

>>> str(type(System)).startswith("<class 'builtins.")
False

# Interestingly?
>>> inspect.isbuiltin(System)
False
>>> inspect.isbuiltin(System.Cpu)
False

Is this because the classattr is an instance of the pyclass, and not actually the pyclass itself? For example, if I put Cpu in pymodule then I get this:

>>> from pyo3_ext import System, Cpu
>>> inspect.isclass(System.Cpu)
False
>>> inspect.isclass(Cpu)
True

So the "Cpu" attribute of "System" is not the same thing as the actual class?

[alex]

I think you want something like:

#[pyo3::pymethods]
impl System {
    #[classattr]
    fn Cpu(py: pyo3::Python<'_>) -> pyo3::Bound<'_, pyo3::types::PyType> {
        py.get_type_bound::<Cpu>()
    }
}

[DavidAntliff]

Ah, that seems to work better:

>>> from pyo3_ext import System
>>> inspect.isclass(System.Cpu)
True

I'll run with this and see how far I get. Thank you.