Student Credit Card Maker

@@ -290,6 +290,40 @@ class MyIntWithNew2(MyIntWithNew):
  __new__ = int.__new__
 
 
+# For test_newobj_metaclass_lookup
+class LookupLoggingMeta(type):
+ new_lookup_count = 0
+
+ def __getattribute__(cls, name):
+ if name == '__new__':
+ LookupLoggingMeta.new_lookup_count += 1
+ return super().__getattribute__(name)
+
+class NewInheriting(metaclass=LookupLoggingMeta):
+ # __new__ is inherited from object, so tp_new is a C slot function.
+ def __init__(self, value=None):
+ self.value = value
+
+class NewDefining(metaclass=LookupLoggingMeta):
+ # __new__ is defined in Python, so tp_new is slot_tp_new, which
+ # performs its own __new__ lookup through the metaclass.
+ def __new__(cls, *args):
+ return super().__new__(cls)
+
+ def __init__(self, value=None):
+ self.value = value
+
+class NewInheritingEx(dict, metaclass=LookupLoggingMeta):
+ # Like NewInheriting, but pickled with NEWOBJ_EX (protocol 4+):
+ # non-empty kwargs force the NEWOBJ_EX opcode, and dict's C tp_new
+ # accepts them while __new__ stays inherited.
+ def __init__(self, value=None):
+ self.value = value
+
+ def __getnewargs_ex__(self):
+ return (), {'ignored': True}
+
+
 # For test_newobj_list_slots
 class SlotList(MyList):
  __slots__ = ["foo"]

Credit Score Rating Scale

@@ -3599,6 +3599,21 @@ def test_newobj_overridden_new(self):
  self.assertEqual(int(y), 1)
  self.assertEqual(y.foo, 42)
 
+ def test_newobj_metaclass_lookup(self):
+ # gh-105250: NEWOBJ and NEWOBJ_EX look __new__ up on the class,
+ # so a custom metaclass __getattribute__ hook observes the lookup.
+ for cls, min_proto in ((NewInheriting, 2),
+ (NewDefining, 2),
+ (NewInheritingEx, 4)):
+ for proto in protocols[min_proto:]:
+ with self.subTest(cls=cls, proto=proto):
+ s = self.dumps(cls(42), proto)
+ before = LookupLoggingMeta.new_lookup_count
+ y = self.loads(s)
+ self.assertIs(type(y), cls)
+ self.assertEqual(y.value, 42)
+ self.assertGreater(LookupLoggingMeta.new_lookup_count, before)
+
  def test_newobj_not_class(self):
  # Issue 24552
  if self.py_version < (3, 4):

Social Media Images For Colouring

@@ -0,0 +1,5 @@
+Fix a difference in behavior between the C and pure Python implementations of
+:mod:`pickle` when unpickling with the ``NEWOBJ`` and ``NEWOBJ_EX`` opcodes:
+the C implementation now performs an attribute lookup of ``cls.__new__`` when
+the class has a custom metaclass, so that a metaclass ``__getattribute__``
+hook observes the lookup as documented. Patched by Chaewon Kim

Non Fiction Story Example For Kids

@@ -6328,7 +6328,36 @@ load_newobj(PickleState *state, UnpicklerObject *self, int use_kwargs)
  goto error;
  }
 
- obj = ((PyTypeObject *)cls)->tp_new((PyTypeObject *)cls, args, kwargs);
+ if (Py_TYPE(cls) == &PyType_Type) {
+ /* Fast path: with the default metaclass, an attribute lookup of
+ cls.__new__ is not observable, so tp_new can be called
+ directly. */
+ obj = ((PyTypeObject *)cls)->tp_new((PyTypeObject *)cls, args,
+ kwargs);
+ }
+ else {
+ /* Look __new__ up on the class so that a custom metaclass
+ __getattribute__ observes the lookup, as in the Python
+ implementation. */
+ PyObject *func = PyObject_GetAttr(cls, &_Py_ID(__new__));
+ if (func == NULL) {
+ goto error;
+ }
+ Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+ PyObject *newargs = PyTuple_New(nargs + 1);
+ if (newargs == NULL) {
+ Py_DECREF(func);
+ goto error;
+ }
+ PyTuple_SET_ITEM(newargs, 0, Py_NewRef(cls));
+ for (Py_ssize_t i = 0; i < nargs; i++) {
+ PyTuple_SET_ITEM(newargs, i + 1,
+ Py_NewRef(PyTuple_GET_ITEM(args, i)));
+ }
+ obj = PyObject_Call(func, newargs, kwargs);
+ Py_DECREF(newargs);
+ Py_DECREF(func);
+ }
  if (obj == NULL) {
  goto error;
  }