[Feature Request] Return vector of different types

[laerne]

Hello !

I have a C++ function, let's call it makeStuff() that returns a vector of object of a certain class, say A.
However it doesn't truly return a vector of A, but instead a vector of unique pointer to A.
This allows the vector to be filled with objects which are not A, but a subclass of A, say B.

However, if I expose makeStuff, A and B, pybind11 fails to detect that some of the items in the return value of makeStuff are actually B and not A.
Which that the python code considers every object in the converted list to be of type A, regardless of the actual type pointed to in the C++ vector.

I would have loved that using py::list directly in C++ and return that, but even though there's plethora of documentation on how to cast a py::object to a pure C++ type using py::cast, there no documentation about the inverse: how to wrap in C++ a concrete C++ object into a py::object.

So I guess I would like to...
...either have a flag to tell pybind11 to detect the actually types of object pointed by unique_ptr's or shared_ptr's, see if it has a type registered for that concrete type, and prefer to use that type to wrap around the object.
...or have a simple and well-documented way to cast form a custom C++ type registered with py::class_ to a py::object, move-only if needed.

Below is a minimal reproduction of the issue:

CMakeLists.txt:

cmake_minimum_required(VERSION 3.27)
project(stackoverflowexample)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

include(FetchContent)
FetchContent_Declare(
  pybind11
  GIT_REPOSITORY https://github.com/pybind/pybind11.git
  GIT_TAG        v2.11.1)
FetchContent_MakeAvailable(pybind11)

find_package (Python COMPONENTS Interpreter Development)

add_library(soe SHARED stackoverflowexample.cpp)
target_link_libraries(soe pybind11::pybind11)

stackoverflowexample.cpp

#include <vector>
#include <memory>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/functional.h>

class A {
public:
  float x = 0;
};

class B : public A {
public:
  float w = 1;
};

std::vector<std::unique_ptr<A>> makeStuff() {
  std::vector<std::unique_ptr<A>> stuff;
  stuff.push_back(std::make_unique<A>());
  stuff.push_back(std::make_unique<B>());
  return stuff;
}

PYBIND11_MODULE(soe, m) {
  pybind11::class_<A>(m, "A")
    .def(pybind11::init<>())
    .def_readwrite("x", &A::x);

  pybind11::class_<B, A>(m, "B")
    .def(pybind11::init<>())
    .def_readwrite("w", &B::w);

  m.def("make_stuff", &makeStuff);
}

the actual python call:

>>> import soe
>>> soe.make_stuff()
[<soe.A object at 0x7f2ac0a2a5b0>, <soe.A object at 0x7f2ac0a2b5f0>]

what I would like to have in python:

>>> import soe
>>> soe.make_stuff()
[<soe.A object at 0x7f2ac0a2a5b0>, <soe.B object at 0x7f2ac0a2b5f0>]