Hi,

I currently use pybind11 to create Python bindings for my library and it's all working as I want. However, I would like to switch to nanobind and I am facing some problems when it comes to binding various class factory constructors.

Using pybind11, I have something like this:

py::class_<libOpenCOR::SedDocument, libOpenCOR::Logger, libOpenCOR::SedDocumentPtr> sedDocument(m, "SedDocument");

sedDocument.def(py::init(&libOpenCOR::SedDocument::create),
                "Create a SedDocument object.",
                py::arg("file") = libOpenCOR::FilePtr())
    ...;

py::class_<libOpenCOR::SolverForwardEuler, libOpenCOR::SolverOdeFixedStep, libOpenCOR::SolverForwardEulerPtr> solverForwardEuler(m, "SolverForwardEuler");

solverForwardEuler.def(py::init(&libOpenCOR::SolverForwardEuler::create),
                       "Create a SolverForwardEuler object.");

Using nanobind, I have converted the above to:

nb::class_<libOpenCOR::SedDocument, libOpenCOR::Logger> sedDocument(m, "SedDocument");

sedDocument.def(nb::new_(&libOpenCOR::SedDocument::create),
                "Create a SedDocument object.",
                nb::arg("file") = nb::none())
    ...;
                   
nb::class_<libOpenCOR::SolverForwardEuler, libOpenCOR::SolverOdeFixedStep> solverForwardEuler(m, "SolverForwardEuler");

solverForwardEuler.def(nb::new_(&libOpenCOR::SolverForwardEuler::create),
                       "Create a SolverForwardEuler object.");

However, when I run my Python tests, I get the following error for my SedDocument class:

>       document = oc.SedDocument()
E       TypeError: __new__(): incompatible function arguments. The following argument types are supported:
E           1. __new__(cls: object, file: libopencor.module.File | None = None) -> libopencor.module.SedDocument

And, for my SolverForwardEuler class, I get:

>       solver = oc.SolverForwardEuler()
E       TypeError: __new__(): incompatible function arguments. The following argument types are supported:
E           1. __new__(arg: object, /) -> libopencor.module.SolverForwardEuler

Regarding my SedDocument class, the factory class factory constructor has the following signature:

static SedDocumentPtr create(const FilePtr &pFile = {});

where SedDocumentPtr is std::shared_ptr<SedDocument> (and something similar for FilePtr). Otherwise, yes, the argument is optional, hence I would like to be able to call it from Python using either document = oc.SedDocument(), document = oc.SedDocument(file) (where file is some FilePtr object) or even document = oc.SedDocument(None). The last two calls are possible, but not the first one.

For my SolverForwardEuler class, I have:

static SolverForwardEulerPtr create();

where SolverForwardEulerPtr is std::shared_ptr<SolverForwardEuler>. So, from Python, I would just like to be able to call solver = oc.SolverForwardEuler(), but this is simply not working.

I have tried various things, but the only thing that has worked so far is to use def_static(), but I clearly don't want my users to do something like document = oc.SedDocument.create() or solver = oc.SolverForwardEuler.create().

Regarding my SedDocument class's factory constructor, I get the feeling (from https://nanobind.readthedocs.io/en/latest/porting.html#none-null-arguments) that I might not be able to have an optional parameter with a default of value of None in Python? So, my binding code above might just be ineffective? Still, I have tried with:

sedDocument.def(nb::new_([]() {
               return libOpenCOR::SedDocument::create();
           }),
           "Create a SedDocument object.")
           .def(nb::new_([](const libOpenCOR::FilePtr &pFile) {
               return libOpenCOR::SedDocument::create(pFile);
           }),
           "Create a SedDocument object.")

but then I get the following error when running my Python tests:

>       document = oc.SedDocument()
E       TypeError: __new__(): incompatible function arguments. The following argument types are supported:
E           1. __new__(arg0: object, arg1: libopencor.module.File, /) -> libopencor.module.SedDocument

I would imagine that what I want to do is very "basic", so it must be possible using nanobind, not least since https://nanobind.readthedocs.io/en/latest/api_core.html#_CPPv4I0EN8nanobind4new_E illustrates exactly what I am after (minus the optional parameter).

So, what am I missing?...