Being able to support dynamic amount of properties

[tapika]

It would be nice to be able to support dynamic amount of properties in class. Theoretically it can be achieved using code snippet like this:

nb::class_<Wrapper>(m, "Wrapper")

    .def_prop_rw("MyProperty",
       [](Wrapper& wrapper) { ... },
       [](Wrapper& wrapper, bool value) { ... }
    )

    .def("__getattr__", 
       [](Wrapper& wrapper, const std::string& propertyName)
       {
           return dynamic_properties[propertyName];
       })

    .def("__setattr__", 
       [](Wrapper& wrapper, const std::string& propertyName, nb::object value)
       {
           dynamic_properties[propertyName] = value;
       })

Class will have MyProperty and any amount of properties from dynamic_properties.

And this code would work fine:

Wrapper w
print(w.MyProperty)

However - assignment will work for dynamic properties, but not for property defined by nanobind.

w.MyProperty = True

Issue seems to be that this assignment will call __setattr__ without further call to [](Wrapper& wrapper, bool value) { ... }.

What I was thinking - is that maybe instead of using __getattr__ and __setattr__, I would register dynamic properties in similar manner to def_prop_rw method call.

Both approach seems to be bit difficult, maybe you can recommend better approach ?

[wjakob]

I think this is more of a question than a bug report, so I converted it to a discussion. I don't have any good ideas, but perhaps others can comment.

[tapika]

Apparently nanobind registers it's own type, and we can query if we have some attribute registered or not.

If attribute is registered - then we can use PyObject_GenericSetAttr method which will dispatch set attr into correct nanobind handler.

Otherwise we can just set the value into dynamic properties container.

.def("__setattr__", [](Wrapper& wrap, const nb::object& name, nb::object value)
    {
        static PyObject* typeInfo = nullptr;
        if (typeInfo == nullptr)
        {
            typeInfo = nb::detail::nb_type_lookup(&typeid(Wrapper));
            if (!typeInfo)
            {
                throw std::runtime_error("Internal failure: python type lookup");
            }
        }
                
        nb::object attr = nb::getattr(typeInfo, name, Py_None);

        if (!attr.is_none())
        {
            // if nanobind has registered it's own property, then set property via that handler
            nb::object self = nb::steal(nb::detail::make_caster<Wrapper>::from_cpp( wrap, nb::rv_policy::reference, nullptr));
            if (PyObject_GenericSetAttr(self.ptr(), name.ptr(), value.ptr()))
            {
                 nb::detail::raise_python_error();
            }
            return;
        }

        wrap.SetValue(nb::cast<std::string>(name), value); // or dynamic_properties[(std::string>(name))] = value;
    }
)