Python & C++ - pybind11 实现解析

// NOTE: _T = typing.TypeVar('_T') and Any/Type/Union/Mapping/Optional are defines by the Python typing module.
    static PyMethodDef PyMethods[] = {
        { PyGenUtil::PostInitFuncName, PyCFunctionCast(&FMethods::PostInit), METH_NOARGS, "_post_init(self) -> None -- called during Unreal object initialization (equivalent to PostInitProperties in C++)" },
        { "cast", PyCFunctionCast(&FMethods::Cast), METH_VARARGS | METH_CLASS, "cast(cls: Type[_T], object: object) -> _T -- cast the given object to this Unreal object type or raise an exception if the cast is not possible" },
        { "get_default_object", PyCFunctionCast(&FMethods::GetDefaultObject), METH_NOARGS | METH_CLASS, "get_default_object(cls: Type[_T]) -> _T -- get the Unreal class default object (CDO) of this type" },
        { "static_class", PyCFunctionCast(&FMethods::StaticClass), METH_NOARGS | METH_CLASS, "static_class(cls) -> Class -- get the Unreal class of this type" },
        { "get_class", PyCFunctionCast(&FMethods::GetClass), METH_NOARGS, "get_class(self) -> Class -- get the Unreal class of this instance" },
        { "get_outer", PyCFunctionCast(&FMethods::GetOuter), METH_NOARGS, "get_outer(self) -> Any -- get the outer object from this instance (if any)" },
        { "get_typed_outer", PyCFunctionCast(&FMethods::GetTypedOuter), METH_VARARGS, "get_typed_outer(self, type: Union[Class, type]) -> Any -- get the first outer object of the given type from this instance (if any)" },
        { "get_outermost", PyCFunctionCast(&FMethods::GetOutermost), METH_NOARGS, "get_outermost(self) -> Package -- get the outermost object (the package) from this instance" },
        { "is_package_external", PyCFunctionCast(&FMethods::IsPackageExternal), METH_NOARGS, "is_package_external(self) -> bool -- returns true if this instance has a different package than its outer's package" },
        { "get_package", PyCFunctionCast(&FMethods::GetPackage), METH_NOARGS, "get_package(self) -> Package -- get the package directly associated with this instance" },
        { "get_name", PyCFunctionCast(&FMethods::GetName), METH_NOARGS, "get_name(self) -> str -- get the name of this instance" },
        { "get_fname", PyCFunctionCast(&FMethods::GetFName), METH_NOARGS, "get_fname(self) -> Name -- get the name of this instance" },
        { "get_full_name", PyCFunctionCast(&FMethods::GetFullName), METH_NOARGS, "get_full_name(self) -> str -- get the full name (class name + full path) of this instance" },
        { "get_path_name", PyCFunctionCast(&FMethods::GetPathName), METH_NOARGS, "get_path_name(self) -> str -- get the path name of this instance" },
        { "get_world", PyCFunctionCast(&FMethods::GetWorld), METH_NOARGS, "get_world(self) -> Optional[World] -- get the world associated with this instance (if any)" },
        { "modify", PyCFunctionCast(&FMethods::Modify), METH_VARARGS, "modify(self, always_mark_dirty: bool = True) -> bool -- inform that this instance is about to be modified (tracks changes for undo/redo if transactional)" },
        { "rename", PyCFunctionCast(&FMethods::Rename), METH_VARARGS | METH_KEYWORDS, "rename(self, name: Union[Name, str]=\"None\", outer: Optional[Object]=None) -> bool -- rename this instance and/or change its outer" },
        { "get_editor_property", PyCFunctionCast(&FMethods::GetEditorProperty), METH_VARARGS | METH_KEYWORDS, "get_editor_property(self, name: str) -> object -- get the value of any property visible to the editor" },
        { "set_editor_property", PyCFunctionCast(&FMethods::SetEditorProperty), METH_VARARGS | METH_KEYWORDS, "set_editor_property(self, name: str, value: object, notify_mode: PropertyAccessChangeNotifyMode=PropertyAccessChangeNotifyMode.DEFAULT) -> None -- set the value of any property visible to the editor, ensuring that the pre/post change notifications are called" },
        { "set_editor_properties", PyCFunctionCast(&FMethods::SetEditorProperties), METH_VARARGS, "set_editor_properties(self, properties: Mapping[str, object]) -> None -- set the value of any properties visible to the editor (from a name->value dict), ensuring that the pre/post change notifications are called" },
        { "call_method", PyCFunctionCast(&FMethods::CallMethod), METH_VARARGS | METH_KEYWORDS, "call_method(self, name: str, *args: Any, **kwargs: Mapping[str, object]) -> Any -- call a method on this object via Unreal reflection using the given ordered (tuple) or named (dict) argument data - allows calling methods that don't have Python glue" },
        { nullptr, nullptr, 0, nullptr }
    };

    PyTypeObject PyType = {
        PyVarObject_HEAD_INIT(nullptr, 0)
        "_ObjectBase", /* tp_name */
        sizeof(FPyWrapperObject), /* tp_basicsize */
    };

    PyType.tp_base = &PyWrapperBaseType;
    PyType.tp_new = (newfunc)&FFuncs::New;
    PyType.tp_dealloc = (destructor)&FFuncs::Dealloc;
    PyType.tp_init = (initproc)&FFuncs::Init;
    PyType.tp_str = (reprfunc)&FFuncs::Str;
    PyType.tp_repr = (reprfunc)&FFuncs::Str;
    PyType.tp_hash = (hashfunc)&FFuncs::Hash;

    PyType.tp_methods = PyMethods;

    PyType.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
    PyType.tp_doc = "Type for all Unreal exposed object instances";

namespace gbf {
namespace math {

class Vector3 {
 public:
  double x;
  double y;
  double z;

  Vector3() : x(0.0), y(0.0), z(0.0) {}
  Vector3(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {}

  ~Vector3() {}

  // Returns the length (magnitude) of the vector.
  double Length() const;

  /// Extract the primary (dominant) axis from this direction vector
  const Vector3& PrimaryAxis() const;
};

}  // namespace math
}  // namespace gbf

// example 模块的初始化函数
PyObject *PyInit_math3d() {
  static pybind11::module_ math3d("math3d", "pybind11 example plugin");

  pybind11::class_<gbf::math::Vector3>(math3d, "Vector3")
      .def(pybind11::init<>())
      .def(pybind11::init<double, double, double>())
      .def("Length", &gbf::math::Vector3::Length)
      .def("PrimaryAxis", &gbf::math::Vector3::PrimaryAxis)
      .def_readwrite("x", &gbf::math::Vector3::x)
      .def_readwrite("y", &gbf::math::Vector3::y)
      .def_readwrite("z", &gbf::math::Vector3::z)
    ;
  return math3d.ptr();
}

from time import time,ctime
import math3d

a = math3d.Vector3(3, 4, 5)
print('vec:', a.x, a.y, a.z)
print('primary axis:', a.PrimaryAxis())
print(f"vec len: {a.Length()}")

wchar_t libraryPath[] = L"../../../data/python/Lib";
  Py_SetPath(libraryPath);

  // 将 math3d 模块的初始化函数添加到内置模块表
  PyImport_AppendInittab("math3d", &PyInit_math3d);
/ 初始化 Python 解释器
  pybind11::scoped_interpreter guard{};

  PyRun_SimpleString(
 R"(# 此处插入测试用Python脚本)"
  );

template <typename T>
using is_pyobject = std::is_base_of<pyobject_tag, remove_reference_t<T>>;

/** \rst
    A mixin class which adds common functions to `handle`, `object` and various accessors.
    The only requirement for `Derived` is to implement ``PyObject *Derived::ptr() const``.
\endrst */
template <typename Derived>
class object_api : public pyobject_tag {
    const Derived &derived() const { return static_cast<const Derived &>(*this); }

public:
    iterator begin() const;
    iterator end() const;

    item_accessor operator[](handle key) const;
    item_accessor operator[](object &&key) const;
    item_accessor operator[](const char *key) const;

    obj_attr_accessor attr(handle key) const;
    obj_attr_accessor attr(object &&key) const;
    str_attr_accessor attr(const char *key) const;

    /// Check if the given item is contained within this object, i.e. ``item in obj``.
    template <typename T>
    bool contains(T &&item) const;

    template <return_value_policy policy = return_value_policy::automatic_reference,
              typename... Args>
    object operator()(Args &&...args) const;

    /// Equivalent to ``obj is other`` in Python.
    bool is(object_api const &other) const { return derived().ptr() == other.derived().ptr(); }
    /// Equivalent to ``obj is None`` in Python.
    bool is_none() const { return derived().ptr() == Py_None; }
    /// Equivalent to obj == other in Python

    object operator-() const;
    object operator~() const;
    object operator+(object_api const &other) const;
    object operator+=(object_api const &other);
    object operator-(object_api const &other) const;
    object operator-=(object_api const &other);
    object operator*(object_api const &other) const;
    //... 

    PYBIND11_DEPRECATED("Use py::str(obj) instead")
    pybind11::str str() const;

    /// Get or set the object's docstring, i.e. ``obj.__doc__``.
    str_attr_accessor doc() const;

    /// Return the object's current reference count
    int ref_count() const { return static_cast<int>(Py_REFCNT(derived().ptr())); }

    handle get_type() const;
};

pybind11::class_<gbf::math::Vector3>(example, "Vector3")
  .def(pybind11::init<>())
  .def(pybind11::init<double, double, double>())
  .def("Length", &gbf::math::Vector3::Length)
  .def("PrimaryAxis", &gbf::math::Vector3::PrimaryAxis)
  .def_readwrite("x", &gbf::math::Vector3::x)
  .def_readwrite("y", &gbf::math::Vector3::y)
  .def_readwrite("z", &gbf::math::Vector3::z)
;

src = Helper::alloc(std::move(*src));
parent_object = capsule(src, [](void *ptr) { Helper::free(reinterpret_cast<Type *>(ptr)); });

template <typename type_, typename... options>
class class_ {
 public:
  template <typename... Extra>
  class_(handle scope, const char *name, const Extra &...extra) {
        using namespace detail;

        type_record record;
        record.scope = scope;
        record.name = name;
        record.type = &typeid(type);
        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
        record.type_align = alignof(conditional_t<has_alias, type_alias, type> &);
        record.holder_size = sizeof(holder_type);
        record.init_instance = init_instance;
        record.dealloc = dealloc;
        record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;

        set_operator_new<type>(&record);

        /* Register base classes specified via template arguments to class_, if any */
        PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));

        /* Process optional arguments, if any */
        process_attributes<Extra...>::init(extra..., &record);

        generic_type::initialize(record);

        if (has_alias) {
            auto &instances = record.module_local ? get_local_internals().registered_types_cpp
                                                  : get_internals().registered_types_cpp;
            instances[std::type_index(typeid(type_alias))]
                = instances[std::type_index(typeid(type))];
        }

  }
};

auto *metaclass
        = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr() : internals.default_metaclass;

    auto *heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
    heap_type->ht_name = name.release().ptr();
#ifdef PYBIND11_BUILTIN_QUALNAME
    heap_type->ht_qualname = qualname.inc_ref().ptr();
#endif
    auto *type = &heap_type->ht_type;

setattr(rec.scope, rec.name, (PyObject *) type);

auto *tinfo = new detail::type_info();
        tinfo->type = (PyTypeObject *) m_ptr;
        tinfo->cpptype = rec.type;
        //...

        auto &internals = get_internals();
        auto tindex = std::type_index(*rec.type);
        internals.registered_types_cpp[tindex] = tinfo;
        internals.registered_types_py[(PyTypeObject *) m_ptr] = {tinfo};

auto *base = (bases.empty()) ? internals.instance_base : bases[0].ptr();
// ... Some code ignore here
type->tp_base = type_incref((PyTypeObject *) base);

internals_ptr->instance_base = make_object_base_type(internals_ptr->default_metaclass);

pybind11::class_<gbf::math::Vector3>(example, "Vector3")
  .def("Length", &gbf::math::Vector3::Length);

/// Main dispatch logic for calls to functions bound using pybind11
    static PyObject *dispatcher(PyObject *self, PyObject *args_in, PyObject *kwargs_in);

/* No existing overload was found, create a new function object */
            rec->def = new PyMethodDef();
            std::memset(rec->def, 0, sizeof(PyMethodDef));
            rec->def->ml_name = rec->name;
            rec->def->ml_meth
                = reinterpret_cast<PyCFunction>(reinterpret_cast<void (*)()>(dispatcher));
            rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS;

            capsule rec_capsule(unique_rec.release(),
                                [](void *ptr) { destruct((detail::function_record *) ptr); });
            rec_capsule.set_name(detail::get_function_record_capsule_name());
            guarded_strdup.release();

            object scope_module;
            if (rec->scope) {
                if (hasattr(rec->scope, "__module__")) {
                    scope_module = rec->scope.attr("__module__");
                } else if (hasattr(rec->scope, "__name__")) {
                    scope_module = rec->scope.attr("__name__");
                }
            }

            m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr());
            if (!m_ptr) {
                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
            }

inline void add_class_method(object &cls, const char *name_, const cpp_function &cf) {
    cls.attr(cf.name()) = cf;
    //...
}

// Implementing class for py::init<...>()
template <typename... Args>
struct constructor {
  template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
  static void execute(Class &cl, const Extra &...extra) {
    cl.def(
        "__init__", [](value_and_holder &v_h, Args... args) { v_h.value_ptr() = construct_or_initialize<Cpp<Class>>(std::forward<Args>(args)...); },
        is_new_style_constructor(), extra...);
  }


template <typename... Args, typename... Extra>
class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra &...extra) {
    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(init);
    init.execute(*this, extra...);
    return *this;
}

pybind11::class_<gbf::math::Vector3>(example, "Vector3")
      .def(pybind11::init<>())
      .def(pybind11::init<double, double, double>());

template <typename Class, typename... Args, detail::enable_if_t<std::is_constructible<Class, Args...>::value, int> = 0>
inline Class *construct_or_initialize(Args &&...args) {
  return new Class(std::forward<Args>(args)...);
}
template <typename Class, typename... Args, detail::enable_if_t<!std::is_constructible<Class, Args...>::value, int> = 0>
inline Class *construct_or_initialize(Args &&...args) {
  return new Class{std::forward<Args>(args)...};
}

template <typename C, typename D, typename... Extra>
    class_ &def_readwrite(const char *name, D C::*pm, const Extra &...extra) {
        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value,
                      "def_readwrite() requires a class member (or base class member)");
        cpp_function fget([pm](const type &c) -> const D & { return c.*pm; }, is_method(*this)),
            fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
        return *this;
    }

// rec_func must be set for either fget or fset.
    void def_property_static_impl(const char *name,
                                  handle fget,
                                  handle fset,
                                  detail::function_record *rec_func) {
        const auto is_static = (rec_func != nullptr) && !(rec_func->is_method && rec_func->scope);
        const auto has_doc = (rec_func != nullptr) && (rec_func->doc != nullptr)
                             && pybind11::options::show_user_defined_docstrings();
        auto property = handle(
            (PyObject *) (is_static ? get_internals().static_property_type : &PyProperty_Type));
        attr(name) = property(fget.ptr() ? fget : none(),
                              fset.ptr() ? fset : none(),
                              /*deleter*/ none(),
                              pybind11::str(has_doc ? rec_func->doc : ""));
    }

/// The 'instance' type which needs to be standard layout (need to be able to use 'offsetof')
struct instance {
    PyObject_HEAD;
    /// Storage for pointers and holder; see simple_layout, below, for a description
    union {
      void *simple_value_holder[1 + instance_simple_holder_in_ptrs()];
      nonsimple_values_and_holders nonsimple;
    };
    /// Weak references
    PyObject *weakrefs;
    /// If true, the pointer is owned which means we're free to manage it with a holder.
    bool owned : 1;
    // ... some members ignore here
};

struct value_and_holder {
    instance *inst = nullptr;
    size_t index = 0u;
    const detail::type_info *type = nullptr;
    void **vh = nullptr;
    //... some thing ignore here.
};

/** Create the type which can be used as a common base for all classes.  This is
    needed in order to satisfy Python's requirements for multiple inheritance.
    Return value: New reference. */
inline PyObject *make_object_base_type(PyTypeObject *metaclass) {
    constexpr auto *name = "pybind11_object";
    auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));

    /* Danger zone: from now (and until PyType_Ready), make sure to
       issue no Python C API calls which could potentially invoke the
       garbage collector (the GC will call type_traverse(), which will in
       turn find the newly constructed type in an invalid state) */
    auto *heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
    if (!heap_type) {
        pybind11_fail("make_object_base_type(): error allocating type!");
    }

    heap_type->ht_name = name_obj.inc_ref().ptr();
#ifdef PYBIND11_BUILTIN_QUALNAME
    heap_type->ht_qualname = name_obj.inc_ref().ptr();
#endif

    auto *type = &heap_type->ht_type;
    type->tp_name = name;
    type->tp_base = type_incref(&PyBaseObject_Type);
    type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
    type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;

    type->tp_new = pybind11_object_new;
    type->tp_init = pybind11_object_init;
    type->tp_dealloc = pybind11_object_dealloc;

    /* Support weak references (needed for the keep_alive feature) */
    type->tp_weaklistoffset = offsetof(instance, weakrefs);

    if (PyType_Ready(type) < 0) {
        pybind11_fail("PyType_Ready failed in make_object_base_type(): " + error_string());
    }

    setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
    PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);

    assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
    return (PyObject *) heap_type;
}

//对象构造相关的 new 和 init 调用
type->tp_new = pybind11_object_new;
type->tp_init = pybind11_object_init;

//对象析构相关的调用
type->tp_dealloc = pybind11_object_dealloc;

math3d.Vector3(3, 4, 5)

/// metaclass `__call__` function that is used to create all pybind11 objects.
extern "C" inline PyObject *pybind11_meta_call(PyObject *type, PyObject *args, PyObject *kwargs) {

    // use the default metaclass call to create/initialize the object
    PyObject *self = PyType_Type.tp_call(type, args, kwargs);
    // ... 
    retrun self;
}

static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    //... some code ignore here
    obj = type->tp_new(type, args, kwds);
    obj = _Py_CheckFunctionResult(tstate, (PyObject*)type, obj, NULL);
    if (obj == NULL)
        return NULL;

    /* If the returned object is not an instance of type,
       it won't be initialized. */
    if (!PyType_IsSubtype(Py_TYPE(obj), type))
        return obj;

    type = Py_TYPE(obj);
    if (type->tp_init != NULL) {
        int res = type->tp_init(obj, args, kwds);
        if (res < 0) {
            assert(_PyErr_Occurred(tstate));
            Py_DECREF(obj);
            obj = NULL;
        }
        else {
            assert(!_PyErr_Occurred(tstate));
        }
    }
    return obj;
}

extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *) {
    return make_new_instance(type);
}

inline PyObject *make_new_instance(PyTypeObject *type) {
#if defined(PYPY_VERSION)
    // PyPy gets tp_basicsize wrong (issue 2482) under multiple inheritance when the first
    // inherited object is a plain Python type (i.e. not derived from an extension type).  Fix it.
    ssize_t instance_size = static_cast<ssize_t>(sizeof(instance));
    if (type->tp_basicsize < instance_size) {
        type->tp_basicsize = instance_size;
    }
#endif
    PyObject *self = type->tp_alloc(type, 0);
    auto *inst = reinterpret_cast<instance *>(self);
    // Allocate the value/holder internals:
    inst->allocate_layout();

    return self;
}

/// An `__init__` function constructs the C++ object. Users should provide at least one
/// of these using `py::init` or directly with `.def(__init__, ...)`. Otherwise, the
/// following default function will be used which simply throws an exception.
extern "C" inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
    PyTypeObject *type = Py_TYPE(self);
    std::string msg = get_fully_qualified_tp_name(type) + ": No constructor defined!";
    PyErr_SetString(PyExc_TypeError, msg.c_str());
    return -1;
}

//对象构造相关的 new 和 init 调用
type->tp_new = pybind11_object_new;
type->tp_init = pybind11_object_init;

//对象析构相关的调用
type->tp_dealloc = pybind11_object_dealloc;

/// Instance destructor function for all pybind11 types. It calls `type_info.dealloc`
/// to destroy the C++ object itself, while the rest is Python bookkeeping.
extern "C" inline void pyra_object_dealloc(PyObject *self) {
    auto *type = Py_TYPE(self);

    // If this is a GC tracked object, untrack it first
    // Note that the track call is implicitly done by the
    // default tp_alloc, which we never override.
    if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC) != 0) {
        PyObject_GC_UnTrack(self);
    }

    clear_instance(self);
    type->tp_free(self);
    // ...
}

class Animal { 
virtual std::string speak() const { return "I am an animal."; } 

class PyAnimal : public Animal { 
public: using Animal::Animal; 
std::string speak() const override { 
  PYBIND11_OVERRIDE_PURE( std::string, // Return type 
  Animal, // Parent class 
  speak // Method name ); } 
};

#pragma once
#include <string>
#include <pybind11/pybind11.h>
#include <pybind11/embed.h>

namespace py = pybind11;

class Derived {
public:
    Derived(const std::string &name) : name_(name) {
        py::module base_module = py::module::import("base");
        py::object base_class = base_module.attr("Base");
        py_instance_ = base_class();
    }

    const std::string &get_name() const {
        return name_;
    }

    std::string foo() {
        return py_instance_.attr("foo")().cast<std::string>();
    }

    std::string bar() {
        return py_instance_.attr("bar")().cast<std::string>();
    }

private:
    std::string name_;
    py::object py_instance_;
};

template <typename type, typename SFINAE = void>
class type_caster : public type_caster_base<type> {};

template <typename T>
struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
};

template <typename T>
struct void_caster {
public:
    bool load(handle src, bool) {
        if (src && src.is_none()) {
            return true;
        }
        return false;
    }
    static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
        return none().release();
    }
    PYBIND11_TYPE_CASTER(T, const_name("None"));
};

template <>
class type_caster<void_type> : public void_caster<void_type> {};

template <>
class type_caster<std::nullptr_t> : public void_caster<std::nullptr_t> {};

template <>
class type_caster<bool> {

// Helper class for UTF-{8,16,32} C++ stl strings:
template <typename StringType, bool IsView = false>
struct string_caster {
//...
};

template <typename CharT, class Traits, class Allocator>
struct type_caster<std::basic_string<CharT, Traits, Allocator>,
                   enable_if_t<is_std_char_type<CharT>::value>>
    : string_caster<std::basic_string<CharT, Traits, Allocator>> {};

template <typename CharT, class Traits>
struct type_caster<std::basic_string_view<CharT, Traits>,
                   enable_if_t<is_std_char_type<CharT>::value>>
    : string_caster<std::basic_string_view<CharT, Traits>, true> {};

using StringType = std::basic_string<CharT>;
using StringCaster = make_caster<StringType>;

template <typename type>
struct pyobject_caster {
    template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
    pyobject_caster() : value() {}

    // `type` may not be default constructible (e.g. frozenset, anyset).  Initializing `value`
    // to a nil handle is safe since it will only be accessed if `load` succeeds.
    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
    pyobject_caster() : value(reinterpret_steal<type>(handle())) {}

    template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
    bool load(handle src, bool /* convert */) {
        value = src;
        return static_cast<bool>(value);
    }

    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
    bool load(handle src, bool /* convert */) {
        if (!isinstance<type>(src)) {
            return false;
        }
        value = reinterpret_borrow<type>(src);
        return true;
    }

    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
    }
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
};

template <typename T>
class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> {};

template <typename type, typename SFINAE = void>
class type_caster : public type_caster_base<type> {};

/// Generic type caster for objects stored on the heap
template <typename type>
class type_caster_base : public type_caster_generic{
  //...
};

PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
    if (!src) {
        return false;
    }
    if (!typeinfo) {
        return try_load_foreign_module_local(src);
    }

    auto &this_ = static_cast<ThisT &>(*this);
    this_.check_holder_compat();

    PyTypeObject *srctype = Py_TYPE(src.ptr());

    // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
    // the instance's value pointer to the target type:
    if (srctype == typeinfo->type) {
        this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
        return true;
    }
    //...
}

PYBIND11_NOINLINE static handle cast(const void *_src,
                                         return_value_policy policy,
                                         handle parent,
                                         const detail::type_info *tinfo,
                                         void *(*copy_constructor)(const void *),
                                         void *(*move_constructor)(const void *),
                                         const void *existing_holder = nullptr) {
        if (!tinfo) { // no type info: error will be set already
            return handle();
        }

        void *src = const_cast<void *>(_src);
        if (src == nullptr) {
            return none().release();
        }

        if (handle registered_inst = find_registered_python_instance(src, tinfo)) {
            return registered_inst;
        }

        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
        auto *wrapper = reinterpret_cast<instance *>(inst.ptr());
        wrapper->owned = false;
        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();

        switch (policy) {
            case return_value_policy::copy:
                if (copy_constructor) {
                    valueptr = copy_constructor(src);
                } else {
#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
                    std::string type_name(tinfo->cpptype->name());
                    detail::clean_type_id(type_name);
                    throw cast_error("return_value_policy = copy, but type " + type_name
                                     + " is non-copyable!");
#else
                    throw cast_error("return_value_policy = copy, but type is "
                                     "non-copyable! (#define PYBIND11_DETAILED_ERROR_MESSAGES or "
                                     "compile in debug mode for details)");
#endif
                }
                wrapper->owned = true;
                break;
            //... some cases ignore here
            default:
                throw cast_error("unhandled return_value_policy: should not happen!");
        }

        tinfo->init_instance(wrapper, existing_holder);

        return inst.release();
    }

template <typename type>
using make_caster = type_caster<intrinsic_t<type>>;

template <typename T>
struct intrinsic_type {
    using type = T;
};
template <typename T>
struct intrinsic_type<const T> {
    using type = typename intrinsic_type<T>::type;
};
template <typename T>
struct intrinsic_type<T *> {
    using type = typename intrinsic_type<T>::type;
};
template <typename T>
struct intrinsic_type<T &> {
    using type = typename intrinsic_type<T>::type;
};
//...

/// Special internal constructor for functors, lambda functions, etc.
    template <typename Func, typename Return, typename... Args, typename... Extra>
    void initialize(Func &&f, Return (*)(Args...), const Extra &...extra) {
    //...

    /* Type casters for the function arguments and return value */
    using cast_in = argument_loader<Args...>;
    using cast_out
        = make_caster<conditional_t<std::is_void<Return>::value, void_type, Return>>;

    //...
}

/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
    cast_in args_converter;

    /* Try to cast the function arguments into the C++ domain */
    if (!args_converter.load_args(call)) {
        return PYBIND11_TRY_NEXT_OVERLOAD;
    }

    /* Invoke call policy pre-call hook */
    process_attributes<Extra...>::precall(call);

    /* Get a pointer to the capture object */
    const auto *data = (sizeof(capture) <= sizeof(call.func.data) ? &call.func.data
                                                                  : call.func.data[0]);
    auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));

    /* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
    return_value_policy policy
        = return_value_policy_override<Return>::policy(call.func.policy);

    /* Function scope guard -- defaults to the compile-to-nothing `void_type` */
    using Guard = extract_guard_t<Extra...>;

    /* Perform the function call */
    handle result
        = cast_out::cast(std::move(args_converter).template call<Return, Guard>(cap->f),
                         policy,
                         call.parent);

    /* Invoke call policy post-call hook */
    process_attributes<Extra...>::postcall(call, result);

    return result;
};

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <stdexcept>

namespace py = pybind11;

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero!");
    }
    return a / b;
}

PYBIND11_MODULE(exception_example, m) {
    m.doc() = "Exception handling example";

    m.def("divide", &divide, "Divide a by b");

    // Register C++ exception for translation to Python exception
    py::register_exception<std::runtime_error>(m, "CppRuntimeError");
}

import exception_example

try:
    result = exception_example.divide(10, 2)
    print(result)  # 输出 5
except exception_example.CppRuntimeError as e:
    print(f"Caught C++ exception: {e}")

try:
    result = exception_example.divide(10, 0)
    print(result)
except exception_example.CppRuntimeError as e:
    print(f"Caught C++ exception: {e}")  # 输出 "Caught C++ exception: Division by zero!"

def add(a, b):
    if not isinstance(a, int) or not isinstance(b, int):
        raise ValueError("Both arguments must be integers")
    return a + b

#include <iostream>
#include <pybind11/pybind11.h>
#include <pybind11/embed.h>

namespace py = pybind11;

int main() {
    py::scoped_interpreter guard{}; // Start Python interpreter

    py::module module = py::module::import("python_function");
    py::function add = module.attr("add");

    try {
        int a = 2;
        std::string b = "3";
        int result = add(a, b).cast<int>();
        std::cout << a << " + " << b << " = " << result << std::endl;
    } catch (const py::error_already_set &e) {
        std::cerr << "Caught Python exception: " << e.what() << std::endl;
        e.restore(); // 重新抛出异常，这样 Python 可以提取更多信息
        PyErr_Print(); // 打印完整的 Python 错误信息
    }

    return 0;
}