Setting attributes of parent class from child class __init__ issue (external C module)

[ghost]

Hi,

I have the following simple external C module class object that I am building in MicroPython 1.19.1:

typedef struct{
    mp_obj_base_t base;
    mp_float_t width;
    mp_float_t height;
}example_node_class_obj_t;

const mp_obj_type_t example_node_class_type;


STATIC void example_node_class_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind){
    ...
}


mp_obj_t example_node_class_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args){
    example_node_class_obj_t *example_node = m_new_obj(example_node_class_obj_t);
    example_node->base.type = &example_node_class_type;
    
    example_node->width = 15.0f;
    example_node->height = 5.0f;

    return MP_OBJ_FROM_PTR(example_node);
}


STATIC void example_node_class_attr(mp_obj_t self_in, qstr attribute, mp_obj_t *destination){
    ENGINE_INFO_PRINTF("Accessing ExampleNode attr");

    example_node_class_obj_t *self = self_in;

    if(destination[0] == MP_OBJ_NULL){          // Load
        switch(attribute){
            case MP_QSTR_width:
                destination[0] = mp_obj_new_float(self->width);
            break;
            case MP_QSTR_height:
                destination[0] = mp_obj_new_float(self->height);
            break;
            default:
                return; // Fail
        }
    }else if(destination[1] != MP_OBJ_NULL){    // Store
        switch(attribute){
            case MP_QSTR_width:
                self->width = mp_obj_get_float(destination[1]);
            break;
            case MP_QSTR_height:
                self->height = mp_obj_get_float(destination[1]);
            break;
            default:
                return; // Fail
        }

        // Success
        destination[0] = MP_OBJ_NULL;
    }
}


STATIC const mp_rom_map_elem_t example_node_class_locals_dict_table[] = {

};

STATIC MP_DEFINE_CONST_DICT(example_node_class_locals_dict, example_node_class_locals_dict_table);

const mp_obj_type_t example_node_class_type = {
    { &mp_type_type },
    .name = MP_QSTR_ExampleNode,
    .print = example_node_class_print,
    .make_new = example_node_class_new,
    .call = NULL,
    .unary_op = NULL,
    .binary_op = NULL,
    .attr = example_node_class_attr,
    .subscr = NULL,
    .getiter = NULL,
    .iternext = NULL,
    .buffer_p = {NULL},
    .locals_dict = (mp_obj_dict_t*)&example_node_class_locals_dict,
};

The above will get exposed through some module. The problem I am having is with not being able to set attributes of the parent in a child class as seen below:

from whatever import ExampleNode

class ChildClass(ExampleNode):
    def __init__(self):
        super().__init__(self)
        self.width = 100
        self.height = 100

Now the problem above is that when setting the width and height the print statement in example_node_class_attr is never output meaning the values were never stored in the internal structure. The way I am using this in reality is that pointers to the self in the make_new function are stored elsewhere then accessed. However, instead of being able to access the values set in the __init__ function through pointer_to_self->width I need to do a mp_load_attr(pointer_to_self, MP_QSTR_width) for example. Is this expected behavior? Is there a way around it?

Being able to have the values stored in an direct access sort of way in C is much better than needing to do a mp_load_attr for what I am doing.

Any help is appreciated. Please let me know if you need more information.

[jimmo]

@jmtinycircuits Unfortunately for optimisation/space reasons there are several limitations placed on inheritance from built-in types. This stems from the fact that inheritance from built-in (native) types works differently to inheritance from instance types.

The main thing to be aware of is that a type's attr handler is not equivalent to Python's __setattr__ (i.e. it's not polymorphic). Which is why this works in Python (and MicroPython):

class Base:
    def __setattr__(self, n, v):
        print("base set", n, v)

class Derived(Base):
    pass


d = Derived()
d.foo = "hello"

(when the store to d.foo is resolved, it sees Derived as having a __setattr__ method)

Unfortunately I don't see a way to (ab)use this mechanism to achieve what you want.

I think the mp_load_attr workaround you described is the best option.