static PyObject *
xpyb_add_core(PyObject *self, PyObject *args)
{
    PyTypeObject *value, *setup;
    PyObject *events, *errors;

    if (xpybModule_core != NULL)
	Py_RETURN_NONE;

    if (!PyArg_ParseTuple(args, "O!O!O!O!", &PyType_Type, &value, &PyType_Type, &setup,
			  &PyDict_Type, &events, &PyDict_Type, &errors))
	return NULL;

    if (!PyType_IsSubtype(value, &xpybExt_type)) {
	PyErr_SetString(xpybExcept_base, "Extension type not derived from xcb.Extension.");
	return NULL;
    }
    if (!PyType_IsSubtype(setup, xpybStruct_type)) {
	PyErr_SetString(xpybExcept_base, "Setup type not derived from xcb.Struct.");
	return NULL;
    }

    Py_INCREF(xpybModule_core = value);
    Py_INCREF(xpybModule_core_events = events);
    Py_INCREF(xpybModule_core_errors = errors);
    Py_INCREF(xpybModule_setup = setup);
    Py_RETURN_NONE;
}

/**
 * Import an existing talloc pointer into a Python object.
 */
_PUBLIC_ PyObject *pytalloc_steal_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx,
				     void *ptr)
{
	PyTypeObject *BaseObjectType = pytalloc_GetBaseObjectType();
	PyTypeObject *ObjectType = pytalloc_GetObjectType();

	if (mem_ctx == NULL) {
		return PyErr_NoMemory();
	}

	if (PyType_IsSubtype(py_type, BaseObjectType)) {
		pytalloc_BaseObject *ret
			= (pytalloc_BaseObject *)py_type->tp_alloc(py_type, 0);

		ret->talloc_ctx = talloc_new(NULL);
		if (ret->talloc_ctx == NULL) {
			return NULL;
		}

		/*
		 * This allows us to keep multiple references to this object -
		 * we only reference this context, which is per ptr, not the
		 * talloc_ctx, which is per pytalloc_Object
		 */
		if (talloc_steal(ret->talloc_ctx, mem_ctx) == NULL) {
			return NULL;
		}
		ret->talloc_ptr_ctx = mem_ctx;
		talloc_set_name_const(ret->talloc_ctx, py_type->tp_name);
		ret->ptr = ptr;
		return (PyObject *)ret;

	} else if (PyType_IsSubtype(py_type, ObjectType)) {
		pytalloc_Object *ret
			= (pytalloc_Object *)py_type->tp_alloc(py_type, 0);

		ret->talloc_ctx = talloc_new(NULL);
		if (ret->talloc_ctx == NULL) {
			return NULL;
		}

		if (talloc_steal(ret->talloc_ctx, mem_ctx) == NULL) {
			return NULL;
		}
		talloc_set_name_const(ret->talloc_ctx, py_type->tp_name);
		ret->ptr = ptr;
		return (PyObject *)ret;
	} else {
		PyErr_SetString(PyExc_RuntimeError,
				"pytalloc_steal_ex() called for object type "
				"not based on talloc");
		return NULL;
	}
}

NUITKA_MAY_BE_UNUSED static PyObject *SELECT_METACLASS( PyObject *metaclass, PyObject *bases )
{
    CHECK_OBJECT( metaclass );
    CHECK_OBJECT( bases );

    if (likely( PyType_Check( metaclass ) ))
    {
        // Determine the proper metatype
        Py_ssize_t nbases = PyTuple_GET_SIZE( bases );
        PyTypeObject *winner = (PyTypeObject *)metaclass;

        for ( int i = 0; i < nbases; i++ )
        {
            PyObject *base = PyTuple_GET_ITEM( bases, i );

            PyTypeObject *base_type = Py_TYPE( base );

            if ( PyType_IsSubtype( winner, base_type ) )
            {
                // Ignore if current winner is already a subtype.
                continue;
            }
            else if ( PyType_IsSubtype( base_type, winner ) )
            {
                // Use if, if it's a subtype of the current winner.
                winner = base_type;
                continue;
            }
            else
            {
                PyErr_Format(
                    PyExc_TypeError,
                    "metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases"
                );

                return NULL;
            }
        }

        if (unlikely( winner == NULL ))
        {
            return NULL;
        }

        return INCREASE_REFCOUNT( (PyObject *)winner );
    }
    else
    {
        return INCREASE_REFCOUNT( metaclass );
    }
}

PyObject *
_pygi_boxed_new (PyTypeObject *type,
                 gpointer      boxed,
                 gboolean      free_on_dealloc)
{
    PyGIBoxed *self;

    if (!boxed) {
        Py_RETURN_NONE;
    }

    if (!PyType_IsSubtype (type, &PyGIBoxed_Type)) {
        PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Boxed");
        return NULL;
    }

    self = (PyGIBoxed *) type->tp_alloc (type, 0);
    if (self == NULL) {
        return NULL;
    }

    ( (PyGBoxed *) self)->gtype = pyg_type_from_object ( (PyObject *) type);
    ( (PyGBoxed *) self)->boxed = boxed;
    ( (PyGBoxed *) self)->free_on_dealloc = free_on_dealloc;
    self->size = 0;
    self->slice_allocated = FALSE;

    return (PyObject *) self;
}

static PyObject* osl_setDrawBuffer(PyObject *self,
                                   PyObject *args,
                                   PyObject *kwargs)
{
    PyObject* buffer;

    if (!PyArg_ParseTuple(args, "O:setDrawBuffer"), &buffer)
        return NULL;

    if (PyInt_Check(buffer))
    {
        oslSetDrawBuffer((OSL_IMAGE*)PyInt_AsLong(buffer));
    }
    else if (PyType_IsSubtype(buffer->ob_type, PPyImageType))
    {
        if (currentDrawBuffer)
        {
            Py_DECREF(currentDrawBuffer);
        }

        oslSetDrawBuffer(((PyImage*)buffer)->pImg);

        Py_INCREF(buffer);
        currentDrawBuffer = buffer;
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Argument must be an osl.Image or predefined constant");
        return NULL;
    }

    Py_INCREF(Py_None);
    return Py_None;
}

PyObject *
pygi_struct_new_from_g_type (GType g_type,
                             gpointer      pointer,
                             gboolean      free_on_dealloc)
{
    PyGIStruct *self;
    PyTypeObject *type;

    type = (PyTypeObject *)pygi_type_import_by_g_type (g_type);

    if (!type)
        type = (PyTypeObject *)&PyGIStruct_Type; /* fallback */

    if (!PyType_IsSubtype (type, &PyGIStruct_Type)) {
        PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Struct");
        return NULL;
    }

    self = (PyGIStruct *) type->tp_alloc (type, 0);
    if (self == NULL) {
        return NULL;
    }

    pyg_pointer_set_ptr (self, pointer);
    ( (PyGPointer *) self)->gtype = g_type;
    self->free_on_dealloc = free_on_dealloc;

    return (PyObject *) self;
}

static PyObject* metaSignalCheck(PyObject* klass, PyObject* args)
{
    if (PyType_IsSubtype(args->ob_type, &PySideSignalInstanceType))
        Py_RETURN_TRUE;
    else
        Py_RETURN_FALSE;
}

NPY_NO_EXPORT int
needs_right_binop_forward(PyObject *self, PyObject *other,
                          char *right_name, int inplace_op)
{
    if (other == NULL ||
        self == NULL ||
        Py_TYPE(self) == Py_TYPE(other) ||
        PyArray_CheckExact(other) ||
        PyArray_CheckAnyScalar(other)) {
        /*
         * Quick cases
         */
        return 0;
    }
    if (!inplace_op && PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self)) ||
        !PyArray_Check(self)) {
        /*
         * Bail out if Python would already have called the right-hand
         * operation.
         */
        return 0;
    }
    if (has_ufunc_attr(other) &&
        PyObject_HasAttrString(other, right_name)) {
        return 1;
    }
    else {
        return 0;
    }
}

static PyObject* pysqlite_row_richcompare(pysqlite_Row *self, PyObject *_other, int opid)
{
    if (opid != Py_EQ && opid != Py_NE) {
#if PY_MAJOR_VERSION < 3
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
#else
        Py_RETURN_NOTIMPLEMENTED;
#endif
    }
    if (PyType_IsSubtype(Py_TYPE(_other), &pysqlite_RowType)) {
        pysqlite_Row *other = (pysqlite_Row *)_other;
        PyObject *res = PyObject_RichCompare(self->description, other->description, opid);
        if ((opid == Py_EQ && res == Py_True)
            || (opid == Py_NE && res == Py_False)) {
            Py_DECREF(res);
            return PyObject_RichCompare(self->data, other->data, opid);
        }
    }
#if PY_MAJOR_VERSION < 3
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
#else
    Py_RETURN_NOTIMPLEMENTED;
#endif
}

int
PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
{
    if (err == NULL || exc == NULL) {
        /* maybe caused by "import exceptions" that failed early on */
        return 0;
    }
    if (PyTuple_Check(exc)) {
        Py_ssize_t i, n;
        n = PyTuple_Size(exc);
        for (i = 0; i < n; i++) {
            /* Test recursively */
             if (PyErr_GivenExceptionMatches(
                 err, PyTuple_GET_ITEM(exc, i)))
             {
                 return 1;
             }
        }
        return 0;
    }
    /* err might be an instance, so check its class. */
    if (PyExceptionInstance_Check(err))
        err = PyExceptionInstance_Class(err);

    if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
        return PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);
    }

    return err == exc;
}

// Trawl a type's hierarchy looking for any slots, signals or properties.
static int trawl_hierarchy(PyTypeObject *pytype, qpycore_metaobject *qo,
        QMetaObjectBuilder &builder, QList<const qpycore_pyqtSignal *> &psigs,
        QMap<uint, PropertyData> &pprops)
{
    if (trawl_type(pytype, qo, builder, psigs, pprops) < 0)
        return -1;

    if (!pytype->tp_bases)
        return 0;

    Q_ASSERT(PyTuple_Check(pytype->tp_bases));

    for (SIP_SSIZE_T i = 0; i < PyTuple_GET_SIZE(pytype->tp_bases); ++i)
    {
        PyTypeObject *sup = (PyTypeObject *)PyTuple_GET_ITEM(pytype->tp_bases, i);

#if PY_MAJOR_VERSION < 3
        /* Ignore classic classes as mixins. */
        if (PyClass_Check((PyObject *)sup))
            continue;
#endif

        if (PyType_IsSubtype(sup, sipTypeAsPyTypeObject(sipType_QObject)))
            continue;

        if (trawl_hierarchy(sup, qo, builder, psigs, pprops) < 0)
            return -1;
    }

    return 0;
}

PyObject *
_pygi_struct_new (PyTypeObject *type,
                  gpointer      pointer,
                  gboolean      free_on_dealloc)
{
    PyGIStruct *self;
    GType g_type;

    if (!PyType_IsSubtype (type, &PyGIStruct_Type)) {
        PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Struct");
        return NULL;
    }

    self = (PyGIStruct *) type->tp_alloc (type, 0);
    if (self == NULL) {
        return NULL;
    }

    g_type = pyg_type_from_object ( (PyObject *) type);

    ( (PyGPointer *) self)->gtype = g_type;
    ( (PyGPointer *) self)->pointer = pointer;
    self->free_on_dealloc = free_on_dealloc;

    return (PyObject *) self;
}

static PlanarBBoxObject *
BBox_new_from_center(PyTypeObject *type, PyObject *args, PyObject *kwargs) 
{
    PlanarBBoxObject *bbox;
    PyObject *center_arg;
    double width, height, cx, cy;
    static char *kwlist[] = {"center", "width", "height", NULL};

    assert(PyType_IsSubtype(type, &PlanarBBoxType));
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
        "Odd:BoundingBox.from_center", kwlist, 
        &center_arg, &width, &height)) {
        return NULL;
    }
    if (!PlanarVec2_Parse(center_arg, &cx, &cy)) {
        PyErr_SetString(PyExc_TypeError,
            "expected Vec2 for argument center");
        return NULL;
    }
    width = fabs(width) * 0.5;
    height = fabs(height) * 0.5;
    bbox = (PlanarBBoxObject *)type->tp_alloc(type, 0);
    if (bbox == NULL) {
        return NULL;
    }
    bbox->min.x = cx - width;
    bbox->min.y = cy - height;
    bbox->max.x = cx + width;
    bbox->max.y = cy + height;
    return bbox;
}

static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
                        CYTHON_UNUSED PyObject *cause) {
    __Pyx_PyThreadState_declare
    /* 'cause' is only used in Py3 */
    Py_XINCREF(type);
    if (!value || value == Py_None)
        value = NULL;
    else
        Py_INCREF(value);

    if (!tb || tb == Py_None)
        tb = NULL;
    else {
        Py_INCREF(tb);
        if (!PyTraceBack_Check(tb)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: arg 3 must be a traceback or None");
            goto raise_error;
        }
    }

    if (PyType_Check(type)) {
        /* instantiate the type now (we don't know when and how it will be caught) */
#if CYTHON_COMPILING_IN_PYPY
        /* PyPy can't handle value == NULL */
        if (!value) {
            Py_INCREF(Py_None);
            value = Py_None;
        }
#endif
        PyErr_NormalizeException(&type, &value, &tb);

    } else {
        /* Raising an instance.  The value should be a dummy. */
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto raise_error;
        }
        /* Normalize to raise <class>, <instance> */
        value = type;
        type = (PyObject*) Py_TYPE(type);
        Py_INCREF(type);
        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: exception class must be a subclass of BaseException");
            goto raise_error;
        }
    }

    __Pyx_PyThreadState_assign
    __Pyx_ErrRestore(type, value, tb);
    return;
raise_error:
    Py_XDECREF(value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
    return;
}

// Return a pointer to the initialised registration structure for a type.
static QQmlPrivate::RegisterSingletonType *init_type(PyTypeObject *py_type,
        PyObject *factory)
{
    // Check the type is derived from QObject.
    if (!PyType_IsSubtype(py_type, sipTypeAsPyTypeObject(sipType_QObject)))
    {
        PyErr_SetString(PyExc_TypeError,
                "type being registered must be a sub-type of QObject");
        return 0;
    }

    // Get the type's number and check there aren't too many.
    int type_nr = QPyQmlSingletonObjectProxy::addType();

    if (type_nr >= NrOfTypes)
    {
        PyErr_Format(PyExc_TypeError,
                "a maximum of %d singleton types may be registered with QML",
                NrOfTypes);
        return 0;
    }

    QQmlPrivate::RegisterSingletonType *rt = &proxy_types[type_nr];

    const QMetaObject *mo = pyqt5_get_qmetaobject(py_type);

    QByteArray ptr_name(py_type->tp_name);
    ptr_name.append('*');

    // Initialise those members that depend on the C++ type.
    switch (type_nr)
    {
        QPYQML_SINGLETON_TYPE_INIT(0);
        QPYQML_SINGLETON_TYPE_INIT(1);
        QPYQML_SINGLETON_TYPE_INIT(2);
        QPYQML_SINGLETON_TYPE_INIT(3);
        QPYQML_SINGLETON_TYPE_INIT(4);
        QPYQML_SINGLETON_TYPE_INIT(5);
        QPYQML_SINGLETON_TYPE_INIT(6);
        QPYQML_SINGLETON_TYPE_INIT(7);
        QPYQML_SINGLETON_TYPE_INIT(8);
        QPYQML_SINGLETON_TYPE_INIT(9);
    }

    // Initialise the remaining members.
    rt->version = 2;
    rt->uri = 0;
    rt->versionMajor = 0;
    rt->versionMinor = 0;
    rt->typeName = 0;
    rt->scriptApi = 0;
    rt->revision = 0;

    Py_INCREF(factory);

    return rt;
}

HyReldep
reldepFromPyObject(PyObject *o)
{
    if (!PyType_IsSubtype(o->ob_type, &reldep_Type)) {
	PyErr_SetString(PyExc_TypeError, "Expected a Reldep object.");
	return NULL;
    }
    return ((_ReldepObject*)o)->reldep;
}

sipErrorState qpyquick_register_type(PyTypeObject *py_type,
        const QMetaObject *mo, const QByteArray &ptr_name,
        const QByteArray &list_name, QQmlPrivate::RegisterType **rtp)
{
#if QT_VERSION >= 0x050200
    if (PyType_IsSubtype(py_type, sipTypeAsPyTypeObject(sipType_QQuickFramebufferObject)))
        return ((*rtp = QPyQuickFramebufferObject::addType(py_type, mo, ptr_name, list_name)) ? sipErrorNone : sipErrorFail);
#endif

    if (PyType_IsSubtype(py_type, sipTypeAsPyTypeObject(sipType_QQuickPaintedItem)))
        return ((*rtp = QPyQuickPaintedItem::addType(py_type, mo, ptr_name, list_name)) ? sipErrorNone : sipErrorFail);

    if (PyType_IsSubtype(py_type, sipTypeAsPyTypeObject(sipType_QQuickItem)))
        return ((*rtp = QPyQuickItem::addType(py_type, mo, ptr_name, list_name)) ? sipErrorNone : sipErrorFail);

    // We don't recognise the type.
    return sipErrorContinue;
}

HyPackage
packageFromPyObject(PyObject *o)
{
    if (!PyType_IsSubtype(o->ob_type, &package_Type)) {
	PyErr_SetString(PyExc_TypeError, "Expected a Package object.");
	return NULL;
    }
    return ((_PackageObject *)o)->package;
}

static int
slpmodule_set__tasklet__(PySlpModuleObject *mod, PyTypeObject *type, void *context)
{
	if (!PyType_IsSubtype(type, &PyTasklet_Type))
		TYPE_ERROR("__tasklet__ must be a tasklet subtype", -1);
	Py_INCREF(type);
	Py_CLEAR(mod->__tasklet__);
	mod->__tasklet__ = type;
	return 0;
}

PyQtGuiObject* QtBaseWidget::getControl() {
	PyQtGuiObject* control = (PyQtGuiObject*) PyWeakref_GET_OBJECT(controlRef);
	if(!control) return NULL;
	if(!PyType_IsSubtype(Py_TYPE(control), &QtGuiObject_Type)) {
		printf("QtBaseWidget: control is wrong type\n");
		return NULL;
	}
	Py_INCREF(control);
	return control;
}