type_caster is not working for converting pandas.Timestamp to custom C++ chrono type

[steve-lorimer]

I have a python API that uses asyncio to download a large quantity of data from a 3rd party vendor and delivers it to the caller in chunks:

I want to wrap this API and expose it to C++. My idea is to pass a std::function bound to a callback, and call this for each chunk of data

async for time, data in async_download:
    cb(time, data)

The time produced in the python API is a pandas.Timestamp.

My company has a custom time class, chrono::Time, which stores time as nanoseconds since the epoch.

To enable conversion from pandas.Timestamp to chrono::Time, I have added the following specialisation:

namespace pybind11::detail {

template<>
struct type_caster<chrono::Time>
{
public:
    PYBIND11_TYPE_CASTER(chrono::Time, const_name("Time"));

    // python -> c++
    bool load(handle src, bool)
    {
        static PyObject* astype_ptr =
            module::import("pandas").attr("Timestamp").attr("value").cast<object>().release().ptr();

        object astype = reinterpret_borrow<object>(astype_ptr);

        PyObject* tmp = PyNumber_Long(astype(src).ptr());
        if (!tmp)
            return false;

        value = chrono::Time::fromEpochNs(PyLong_AsLong(tmp));
        Py_DECREF(tmp);

        return !PyErr_Occurred();
    }

    // c++ -> python
    static handle cast(chrono::Time src, return_value_policy, handle)
    {
        object timestamp = module_::import("pandas").attr("Timestamp");
        return timestamp(src.ns()).release();
    }
};

This, afaik, should allow me to do the following from C++:

py::object pyImportFromFile(std::string_view module, std::string_view path)
{
    py::object globals = py::module::import("__main__").attr("__dict__");

    py::dict locals;
    locals["module_name"] = py::cast(module);
    locals["path"] = py::cast(path);

    py::eval<py::eval_statements>(R"(
        import importlib.util
        module_spec = importlib.util.spec_from_file_location(module_name, path)
        module = importlib.util.module_from_spec(module_spec)
        module_spec.loader.exec_module(module))",
                                  globals,
                                  locals);

    return locals["module"];
}

void foo()
{
    py::object module = pyImportFromFile("vendor_api", "./vendor_api.py");
    py::object download = module.attr("download");

    download("some_identifier", [](chrono::Time time, std::string data)
        {
            // process data...
        });
}

The call to download fails, however, with the following exception:

terminate called after throwing an instance of 'pybind11::error_already_set'
  what():  TypeError: 'getset_descriptor' object is not callable

At:
  ./vendor_api.py(79): download

The above specialisation for chrono::Time works when passing from C++ to python (the type received in python is pandas.Timestamp), but it doesn't seem to be working for passing pandas.Timestamp from python to C++.

How can I enable the automatic conversion of a pandas.Timestamp to my custom chrono::Time class when called from an embedded python script?