Cython emits Python 3 code for __prepare__ in Python 2

Cython is emitting the following code in Python 2:

/* Py3ClassCreate */
  static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
                                           PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
    PyObject *ns;
    if (metaclass) {
        PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare);
        if (prep) {
            PyObject *pargs = PyTuple_Pack(2, name, bases);
            if (unlikely(!pargs)) {
                Py_DECREF(prep);
                return NULL;
            }
            ns = PyObject_Call(prep, pargs, mkw);
            Py_DECREF(prep);
            Py_DECREF(pargs);
        } else {

This code finds the __prepare__ attribute, and, if it exists, calls it as if it were a function. __prepare__ does not exist in Python 2, and should not be called in Python 2, however, Cython will errantly call it.

Typically, it won’t exist, so this path is never triggered. Unfortunately, six just added (in 1.11.0) a __prepare__ function to a dummy class that gets generated upon a call to with_metaclass (in this commit).

That means that the following code:

import six

class SomeBase(object):
    pass

class SomeMeta(type):
    def __new__(cls, name, bases, dct):
        new_cls = super(SomeMeta, cls).__new__(cls, name, bases, dct)
        #new_cls = type.__new__(cls, name, bases, dct)
        return new_cls


#import ipdb; ipdb.set_trace()
class Derived(six.with_metaclass(SomeMeta, SomeBase)):
    pass

will work just fine in Python 2 on its own, but if compiled w/ cython, will result in the above stack trace, since Cython will incorrectly call __prepare__, whereas CPython will not.

[scoder]

Closing as “third party, not a bug in Cython”.

[scoder]

Yes, it’s a bug in six that was introduced here: https://github.com/benjaminp/six/pull/178 It unconditionally calls (the equivalent of) super().__prepare__(), which is not always available in Py2, unless explicitly implemented by users. (That’s probably the “stack trace” that @thanatos was referring to above, but didn’t actually provide.)

The correct fix on their side is to either a) implement __prepare__ only in Py3, or b) call super().__prepare() conditionally only if the original metaclass implements it.