How do I create an instance of a class to return from a different classes method in C code?

[kdschlosser]

Here is what I am wanting to do. This is written in Python so it is easier to understand what I want to do,

class DeviceConnection:

    def __init__(self):
        # code to setup device
        ...

    def recv_message(self):
        # do code to receive message and whatever other information. 
        message = 'received message'
        arg1 = 1
        arg2 = 2
        return Message(message, arg1, arg2)


class Message:

    def __init__(self, message, arg1, arg2):
        self.message = message
        self.arg1 = arg1
        self.arg2 = arg2


device = DeviceConnection()

incoming_message = device.recv_message()
print(incoming_message.message)

I have all of the inner working to access the attributes of the Message class. I am not sure if there is anything special that needs to be done in order to create an instance of the Message class. Would code like this work?

const mp_obj_type_t mp_message_type_t;
const mp_obj_type_t mp_device_type_t;

typedef struct _mp_message_t {
    mp_obj_base_t base;
    mp_obj_t message;
} mp_message_t;

typedef struct _mp_device_t {
    mp_obj_base_t base;
} mp_device_t;

// ************* Here is where I am looking for some help *****************

static mp_obj_t recv_message(mp_obj_t self_in)
{
    mp_device_t *self = MP_OBJ_TO_PTR(self_in);
    // do code to receive message
    
    mp_message_t *instance= m_new_obj(mp_message_t);
    instance->base.type = &mp_message_type_t;
    instance->message = received_message;
    
    return MP_OBJ_FROM_PTR(instance);
}

// ****************************************************************************

static MP_DEFINE_CONST_FUN_OBJ_1(recv_message_obj, recv_message);

#define UNUSED(x)  ((void)x)


static mp_obj_t device_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
{
    UNUSED(n_args);
    UNUSED(n_kw);

    // create new object
    mp_device_t *self = m_new_obj(mp_device_t);
    self->base.type = &mp_device_type_t;

    return MP_OBJ_FROM_PTR(self);
}


static mp_obj_t message_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
{
    UNUSED(n_args);
    UNUSED(n_kw);

    // create new object
    mp_message_t *self = m_new_obj(mp_message_t);
    self->base.type = &mp_message_type_t;

    return MP_OBJ_FROM_PTR(self);
}


static void message_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_message_t *self = MP_OBJ_TO_PTR(self_in);

    if (dest[0] == MP_OBJ_NULL) {
        // getter
    } else if (dest[1]) {
        // setter
    }
}


MP_DEFINE_CONST_OBJ_TYPE(
        mp_message_type_t,
        MP_QSTR_Message,
        MP_TYPE_FLAG_NONE,
        make_new, message_make_new,
        attr, message_attr
);


static const mp_rom_map_elem_t device_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_recv_message),    MP_ROM_PTR(&recv_message_obj) }
};

MP_DEFINE_CONST_DICT(device_locals_dict, device_locals_dict_table);


MP_DEFINE_CONST_OBJ_TYPE(
        mp_device_type_t,
        MP_QSTR_Device,
        MP_TYPE_FLAG_NONE,
        make_new, device_make_new,
        locals_dict, &device_locals_dict,
);

static const mp_rom_map_elem_t mp_module_some_module_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR___name__),           MP_OBJ_NEW_QSTR(MP_QSTR_some_module)        },
    { MP_ROM_QSTR(MP_QSTR_Device),             MP_ROM_PTR(&mp_device_type_t)        },
    { MP_ROM_QSTR(MP_QSTR_Message),             MP_ROM_PTR(&mp_message_type_t)        }
};

static MP_DEFINE_CONST_DICT(mp_module_some_module_globals, mp_module_some_module_globals_table);


const mp_obj_module_t mp_module_some_module = {
    .base    = {&mp_type_module},
    .globals = (mp_obj_dict_t *)&mp_module_some_module_globals,
};

MP_REGISTER_MODULE(MP_QSTR_some_module, mp_module_some_module);