Allow users to specify a custom metaclass

Author: dean0x7d

include/pybind11/attr.h

@@ -53,10 +53,15 @@ struct dynamic_attr { };
 /// Annotation which enables the buffer protocol for a type
 struct buffer_protocol { };
 
-/// DEPRECATED: Annotation which requests that a special metaclass is created for a type
+/// Annotation which requests that a special metaclass is created for a type
 struct metaclass {
+    handle value;
+
     PYBIND11_DEPRECATED("py::metaclass() is no longer required. It's turned on by default now.")
     metaclass() = default;
+
+    /// Override pybind11's default metaclass
+    metaclass(handle value) : value(value) { }
 };
 
 /// Annotation to mark enums as an arithmetic type
@@ -181,6 +186,9 @@ struct type_record {
     /// Optional docstring
     const char *doc = nullptr;
 
+    /// Custom metaclass (optional)
+    handle metaclass;
+
     /// Multiple inheritance marker
     bool multiple_inheritance : 1;
 
@@ -353,8 +361,10 @@ struct process_attribute<buffer_protocol> : process_attribute_default<buffer_pro
     static void init(const buffer_protocol &, type_record *r) { r->buffer_protocol = true; }
 };
 
-// DEPRECATED
-template <> struct process_attribute<metaclass> : process_attribute_default<metaclass> { };
+template <>
+struct process_attribute<metaclass> : process_attribute_default<metaclass> {
+    static void init(const metaclass &m, type_record *r) { r->metaclass = m.value; }
+};
 
 /// Process an 'arithmetic' attribute for enums (does nothing here)
 template <>

include/pybind11/class_support.h

@@ -368,7 +368,9 @@ inline PyObject* make_new_python_type(const type_record &rec) {
        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 metaclass = internals.default_metaclass;
+    auto metaclass = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr()
+                                         : internals.default_metaclass;
+
     auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
     if (!heap_type)
         pybind11_fail(std::string(rec.name) + ": Unable to create type object!");

tests/test_methods_and_attributes.cpp

@@ -245,6 +245,10 @@ test_initializer methods_and_attributes([](py::module &m) {
         .def_property_readonly("rvalue", &TestPropRVP::get_rvalue)
         .def_property_readonly_static("static_rvalue", [](py::object) { return SimpleValue(); });
 
+    struct MetaclassOverride { };
+    py::class_<MetaclassOverride>(m, "MetaclassOverride", py::metaclass((PyObject *) &PyType_Type))
+        .def_property_readonly_static("readonly", [](py::object) { return 1; });
+
 #if !defined(PYPY_VERSION)
     py::class_<DynamicClass>(m, "DynamicClass", py::dynamic_attr())
         .def(py::init());

tests/test_methods_and_attributes.py

@@ -126,6 +126,22 @@ def check_self(self):
     instance.static_cls = check_self
 
 
+def test_metaclass_override():
+    """Overriding pybind11's default metaclass changes the behavior of `static_property`"""
+    from pybind11_tests import MetaclassOverride
+
+    assert type(ExampleMandA).__name__ == "pybind11_type"
+    assert type(MetaclassOverride).__name__ == "type"
+
+    assert MetaclassOverride.readonly == 1
+    assert type(MetaclassOverride.__dict__["readonly"]).__name__ == "pybind11_static_property"
+
+    # Regular `type` replaces the property instead of calling `__set__()`
+    MetaclassOverride.readonly = 2
+    assert MetaclassOverride.readonly == 2
+    assert isinstance(MetaclassOverride.__dict__["readonly"], int)
+
+
 @pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"])
 def test_property_return_value_policies(access):
     from pybind11_tests import TestPropRVP