Use nb::new_ for factory functions with non-movable types

Changed from nb::init to nb::new_ pattern for all factory function
constructors. This allows nanobind to properly handle the raw pointers
returned from .release() without trying to move-construct the objects.

The nb::new_ pattern is specifically designed for custom allocation
and works with types that have deleted copy/move constructors.

Author: snnn

src/python/python.cpp

@@ -361,7 +361,7 @@ NB_MODULE(onnxruntime_genai, m) {
       .def("decode", [](OgaTokenizerStream& t, int32_t token) { return t.Decode(token); });
 
   nb::class_<OgaNamedTensors>(m, "NamedTensors")
-      .def(nb::init([]() { return OgaNamedTensors::Create(); }))
+      .def(nb::new_([]() { return OgaNamedTensors::Create().release(); }), nb::rv_policy::take_ownership)
       .def("__getitem__", [](OgaNamedTensors& named_tensors, const std::string& name) {
         auto tensor = named_tensors.Get(name.c_str());
         if (!tensor)
@@ -391,14 +391,14 @@ NB_MODULE(onnxruntime_genai, m) {
         return keys; });
 
   nb::class_<OgaTensor>(m, "Tensor")
-      .def(nb::init([](nb::ndarray<>& v) { return ToOgaTensor(v); }))
+      .def(nb::new_([](nb::ndarray<>& v) { return ToOgaTensor(v).release(); }), nb::rv_policy::take_ownership)
       .def("shape", &OgaTensor::Shape)
       .def("type", &OgaTensor::Type)
       // .def("data", &OgaTensor::Data) // Exposing raw void* might be unsafe. Consider alternatives.
       .def("as_numpy", [](OgaTensor& t) { return ToNumpy(t); });
 
   nb::class_<OgaTokenizer>(m, "Tokenizer")
-      .def(nb::init([](const OgaModel& model) { return OgaTokenizer::Create(model); }))
+      .def(nb::new_([](const OgaModel& model) { return OgaTokenizer::Create(model).release(); }), nb::rv_policy::take_ownership)
       .def_prop_ro("bos_token_id", &OgaTokenizer::GetBosTokenId)
       .def_prop_ro("eos_token_ids", [](const OgaTokenizer& t) { return ToPython(t.GetEosTokenIds()); })
       .def_prop_ro("pad_token_id", &OgaTokenizer::GetPadTokenId)
@@ -452,7 +452,7 @@ NB_MODULE(onnxruntime_genai, m) {
       .def("create_stream", [](const OgaTokenizer& t) { return OgaTokenizerStream::Create(t); });
 
   nb::class_<OgaConfig>(m, "Config")
-      .def(nb::init([](const std::string& config_path) { return OgaConfig::Create(config_path.c_str()); }))
+      .def(nb::new_([](const std::string& config_path) { return OgaConfig::Create(config_path.c_str()).release(); }), nb::rv_policy::take_ownership)
       .def("append_provider", &OgaConfig::AppendProvider)
       .def("set_provider_option", &OgaConfig::SetProviderOption)
       .def("clear_providers", &OgaConfig::ClearProviders)
@@ -488,8 +488,8 @@ NB_MODULE(onnxruntime_genai, m) {
       .def("clear_decoder_provider_options_hardware_vendor_id", &OgaConfig::ClearDecoderProviderOptionsHardwareVendorId);
 
   nb::class_<OgaModel>(m, "Model")
-      .def(nb::init([](const OgaConfig& config) { return OgaModel::Create(config); }))
-      .def(nb::init([](const std::string& config_path) { return OgaModel::Create(config_path.c_str()); }))
+      .def(nb::new_([](const OgaConfig& config) { return OgaModel::Create(config).release(); }), nb::rv_policy::take_ownership)
+      .def(nb::new_([](const std::string& config_path) { return OgaModel::Create(config_path.c_str()).release(); }), nb::rv_policy::take_ownership)
       .def_prop_ro("type", [](const OgaModel& model) -> std::string { return model.GetType().p_; })
       .def_prop_ro("device_type", [](const OgaModel& model) -> std::string { return model.GetDeviceType().p_; }, "The device type the model is running on")
       // Assuming OgaMultiModalProcessor::Create returns a unique_ptr or needs management
@@ -636,12 +636,12 @@ NB_MODULE(onnxruntime_genai, m) {
       });
 
   nb::class_<OgaAdapters>(m, "Adapters")
-      .def(nb::init([](OgaModel& model) { return OgaAdapters::Create(model); }))
+      .def(nb::new_([](OgaModel& model) { return OgaAdapters::Create(model).release(); }), nb::rv_policy::take_ownership)
       .def("unload", &OgaAdapters::UnloadAdapter)
       .def("load", &OgaAdapters::LoadAdapter);
 
   nb::class_<OgaRequest>(m, "Request")
-      .def(nb::init([](PyGeneratorParams& params) { return OgaRequest::Create(*params.params_); }))
+      .def(nb::new_([](PyGeneratorParams& params) { return OgaRequest::Create(*params.params_).release(); }), nb::rv_policy::take_ownership)
       .def("add_tokens", [](OgaRequest& request, nb::ndarray<const int32_t, nb::shape<-1>, nb::c_contig, nb::device::cpu> tokens) {
         auto sequences = OgaSequences::Create();  // Needs management?
         auto tokens_span = ToSpan(tokens);
@@ -666,7 +666,7 @@ NB_MODULE(onnxruntime_genai, m) {
            return nb::borrow<nb::object>(static_cast<PyObject*>(opaque_data_ptr)); });
 
   nb::class_<OgaEngine>(m, "Engine")
-      .def(nb::init([](OgaModel& model) { return OgaEngine::Create(model); }))
+      .def(nb::new_([](OgaModel& model) { return OgaEngine::Create(model).release(); }), nb::rv_policy::take_ownership)
       .def("add_request", &OgaEngine::Add)
       .def("step", &OgaEngine::Step)
       .def("remove_request", &OgaEngine::Remove)