Defining a custom string class

[HerrNamenlos123]

Hey there, i really love this library, but I have an issue what i think should be possible.
Basically i want to create a custom string class that is derived from std::string, and use it everywhere instead of std::string, but pybind11 does not like it.

Consider following code:

#include <iostream>
#include <chrono>
#include <pybind11/stl.h>
#include <pybind11/embed.h>
namespace py = pybind11;

class Object {
public:
    Object() = default;
    std::string label;
};

PYBIND11_EMBEDDED_MODULE(b, m) {
    py::class_<Object>(m, "Object")
        .def(py::init<>())
        .def_readwrite("label", &Object::label);
}

int main() {
    py::scoped_interpreter guard{}; // start the interpreter and keep it alive
    try {
        py::exec(
            "import b\n"
            "obj = b.Object()\n"
            "obj.label = 'Hello World'\n"
            "print(obj.label)\n"
        );
    } catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
    }
}

I have an object with a string property, that can be assigned and read from. perfect.

But now i want to replace it with my own custom class:

#include <iostream>
#include <chrono>
#include <pybind11/stl.h>
#include <pybind11/embed.h>
namespace py = pybind11;

class String : public std::string {
public:
    String() = default;
    String(const std::string& s) : std::string(s) { }

    operator std::string() { return *this; }
    String& operator=(const std::string& s) { std::string::operator=(s); return *this; }
};

class Object {
public:
    Object() = default;
    String label;
};

PYBIND11_EMBEDDED_MODULE(b, m) {
    py::class_<String>(m, "String")
        .def(py::init<>())
        .def(py::init<const std::string&>())
        // SOME MACIGAL FUNCTIONS HERE
        .def("__str__", [](String& s) { return s; })
        .def("__repr__", [](String& s) { return s; })
        .def("__eq__", [](String& s, const std::string& o) { return s == o; });

    py::class_<Object>(m, "Object")
        .def(py::init<>())
        .def_readwrite("label", &Object::label);
}


int main() {
    py::scoped_interpreter guard{}; // start the interpreter and keep it alive
    try {
        py::exec(
            "import b\n"
            "obj = b.Object()\n"
            "obj.label = 'Hello World'\n"
            "print(obj.label)\n"
        );
    } catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
    }
}

The string class should be a 1-to-1 drop-in replacement of std::string, so no change to the Object.
When executing this code i get the error:

TypeError: (): incompatible function arguments. The following argument types are supported:
    1. (self: b.Object, arg0: b.String) -> None

Invoked with: <b.Object object at 0x000001EDFCF7E2F0>, 'Hello World'

At:
  <string>(4): <module>

What am i missing to tell pybind11 to do this? I really searched a lot and also asked ChatGPT a gazillion times, but no luck.
I am sure it is possible somehow, because std::string itself is also just a class, so why shouldn't i be able to do just the same thing?
Marking the class as derived from std::string in pybind also does not help.

Any help apprechiated...

[HerrNamenlos123]

The answer really always comes up just after asking in a forum.
What does the trick for me:

namespace pybind11::detail {
    template <> struct type_caster<String> : public type_caster_base<String> {
        using base = type_caster_base<String>;
    public:
        bool load(handle src, bool convert) {
            if (base::load(src, convert)) {
                return true;
            }
            else if (py::isinstance<py::str>(src)) {
                value = new String(py::cast<std::string>(src));
                return true;
            }
            return false;
        }

        static handle cast(const String& src, return_value_policy policy, handle parent) {
            return py::cast(std::string(src), policy, parent).release();
        }
    };
}